@xopcai/xopc 0.0.241 → 0.0.243

package/dist/src/voice/realtime/memory-context.js

@@ -0,0 +1,100 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { onUserContextChange } from "../../user-context/changes.js";
+import { getUnderstanding, getUserProfile } from "../../storage/sqlite/user-context-repository.js";
+import { parseAgentSessionKey } from "../../routing/session-key-utils.js";
+import { getSessionMetadata } from "../../storage/sqlite/session-repository.js";
+import { getSessionConfig } from "../../storage/sqlite/config-repository.js";
+import { init_session_key, parseSessionKey } from "../../routing/session-key.js";
+import { getUserFocus } from "../../user-context/sources/repository.js";
+import { allowsAutomaticDisclosure, focusRejectionReason, rejectionReason } from "../../user-context/selection-policy.js";
+import { stripRuntimeContextFromUserMessage } from "../../session/user-message-display.js";
+import { remoteContextEligibleIds } from "../../storage/sqlite/remote-context-repository.js";
+import { selectAutomaticContext } from "../../user-context/automatic-context.js";
+//#region src/voice/realtime/memory-context.ts
+init_session_key();
+init_logger();
+const log = createLogger("Voice:Memory");
+const policyVersion = (config) => JSON.stringify({
+	userContext: config.userContext,
+	agents: config.agents
+});
+function voiceMemoryEnabled(config, sessionKey) {
+	const parsed = parseSessionKey(sessionKey);
+	const rest = parseAgentSessionKey(sessionKey)?.rest;
+	const parts = rest?.split(":") ?? [];
+	const explicitlyPrivate = rest === "main" || parts.every(Boolean) && !["cron", "subagent"].includes(parts[0] ?? "") && (parts[0] === "direct" && parts.length >= 2 || parts[1] === "direct" && parts.length >= 3 || parts[2] === "direct" && parts.length >= 4);
+	const user = config.userContext;
+	if (!parsed || !explicitlyPrivate || parsed.peerKind !== "direct" || !user.enabled || !user.understanding.enabled || user.memory.mode === "off" || !user.memory.sources.includes("understanding")) return false;
+	const mode = getSessionConfig(sessionKey)?.userContextMode;
+	return mode === void 0 || mode === "enabled";
+}
+function voiceMemoryQuery(history) {
+	return history.filter((message) => message.role === "user").slice(-2).map((message) => {
+		return stripRuntimeContextFromUserMessage(typeof message.content === "string" ? message.content : message.content.filter((part) => part.type === "text").map((part) => part.type === "text" ? part.text : "").join("\n")).slice(-300);
+	}).join("\n").slice(-600);
+}
+function buildVoiceMemoryContext(input) {
+	const started = performance.now();
+	try {
+		if (!voiceMemoryEnabled(input.getConfig(), input.sessionKey) || input.maxChars < 128) return;
+		const policy = policyVersion(input.getConfig());
+		const workspace = getSessionConfig(input.sessionKey)?.workingDirectoryOverride;
+		const sessionId = getSessionMetadata(input.sessionKey)?.sessionId;
+		const selection = selectAutomaticContext({
+			...input,
+			query: voiceMemoryQuery(input.history),
+			deadline: started + 150
+		});
+		if (!selection.block) return;
+		let invalid = false;
+		const isCurrent = () => {
+			try {
+				if (invalid || !voiceMemoryEnabled(input.getConfig(), input.sessionKey) || policy !== policyVersion(input.getConfig()) || workspace !== getSessionConfig(input.sessionKey)?.workingDirectoryOverride) return false;
+				const session = getSessionMetadata(input.sessionKey);
+				if (session?.sessionId !== sessionId || session?.projectId !== input.projectId) return false;
+				const understandingIds = selection.references.filter((r) => r.kind === "understanding").map((r) => r.id);
+				const focusIds = selection.references.filter((r) => r.kind === "focus").map((r) => r.id);
+				const allowed = new Set([...remoteContextEligibleIds("understanding", understandingIds), ...remoteContextEligibleIds("focus", focusIds)]);
+				return selection.references.every((ref) => {
+					if (ref.kind === "profile") return ref.version === JSON.stringify(getUserProfile());
+					if (!allowed.has(ref.id)) return false;
+					if (ref.kind === "focus") {
+						const item = getUserFocus(ref.id);
+						return !!item && item.versionId === ref.version && allowsAutomaticDisclosure(item) && !focusRejectionReason(item, input, Date.now());
+					}
+					const item = getUnderstanding(ref.id);
+					return !!item && item.status === "active" && item.versionId === ref.version && allowsAutomaticDisclosure(item) && !rejectionReason(item, input, Date.now(), []);
+				});
+			} catch {
+				return false;
+			}
+		};
+		log.debug({
+			sessionKey: input.sessionKey,
+			selectedCount: selection.references.length,
+			contextChars: selection.block.length,
+			durationMs: performance.now() - started
+		}, "Native voice memory selected");
+		return {
+			...selection,
+			isCurrent,
+			subscribe: (invalidate) => onUserContextChange((change) => {
+				if (change.kind === "policy" || change.kind === "session" && change.id === input.sessionKey && !isCurrent() || selection.references.some((ref) => ref.kind === change.kind && ref.id === change.id)) {
+					if (!isCurrent()) {
+						invalid = true;
+						invalidate();
+					}
+				}
+			})
+		};
+	} catch {
+		log.warn({
+			sessionKey: input.sessionKey,
+			durationMs: performance.now() - started
+		}, "Native voice memory unavailable; continuing with chat history");
+		return;
+	}
+}
+//#endregion
+export { buildVoiceMemoryContext, voiceMemoryEnabled, voiceMemoryQuery };

package/dist/src/voice/realtime/omniEngine.d.ts

@@ -0,0 +1,18 @@
+import type { VoiceEngine, VoiceEventSink } from './engine.js';
+import type { OmniRoute } from './omniRoute.js';
+export interface OmniTranscript {
+    itemId: string;
+    role: 'user' | 'assistant';
+    text: string;
+    interrupted: boolean;
+}
+export declare function createOmniVoiceEngine(options: {
+    callId: string;
+    route: OmniRoute;
+    silenceDurationMs: number;
+    bargeIn: boolean;
+    send: VoiceEventSink;
+    sendAudio: (responseId: string, bytes: Uint8Array) => void;
+    record: (entry: OmniTranscript) => Promise<void>;
+    onClose: (reason: string, notify: boolean) => Promise<void>;
+}): VoiceEngine;

package/dist/src/voice/realtime/omniEngine.js

@@ -0,0 +1,443 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { AudioPlaybackWindow } from "./audio-playback-window.js";
+import crypto from "node:crypto";
+import WebSocket from "ws";
+//#region src/voice/realtime/omniEngine.ts
+init_logger();
+const log = createLogger("Voice:Omni");
+const MAX_QUEUED_AUDIO_BYTES = 24e3 * 2 * 60;
+const MAX_PENDING_INPUT_BYTES = 64 * 1024;
+const UPLOAD_TIMEOUT_MS = 1e4;
+const FAILURE_MESSAGES = {
+	OMNI_UPLOAD_TIMEOUT: "The connection to the voice service stopped uploading audio. Check the network to your configured endpoint and reconnect.",
+	OMNI_INPUT_RESET_TIMEOUT: "The voice service did not acknowledge clearing microphone input. Reconnect to continue.",
+	OMNI_START_TIMEOUT: "The voice service did not become ready in time.",
+	OMNI_CONNECTION_FAILED: "Could not connect to the voice service. Check network and service availability.",
+	OMNI_CONNECTION_REJECTED: "The voice service rejected the connection. Check account access, quota and route configuration.",
+	OMNI_CONNECTION_CLOSED: "The voice service closed the connection.",
+	OMNI_PROVIDER_ERROR: "The voice service reported an error.",
+	OMNI_RESPONSE_FAILED: "The voice service could not complete its reply.",
+	OMNI_INVALID_TRANSCRIPT: "The voice service returned an invalid transcript.",
+	OMNI_INVALID_AUDIO: "The voice service returned invalid audio.",
+	OMNI_TRANSCRIPT_LIMIT: "The voice reply exceeded the transcript limit.",
+	OMNI_PROTOCOL_ERROR: "The voice service returned an unexpected message.",
+	OMNI_ITEM_LIMIT: "This call reached its conversation limit.",
+	TRANSCRIPT_WRITE_FAILED: "The conversation could not be saved. Check gateway storage."
+};
+function createOmniVoiceEngine(options) {
+	let socket;
+	let closed = false;
+	let ready = false;
+	let muted = false;
+	let inputBlocked = false;
+	let clearingInput = false;
+	let clearTimer;
+	const discardedInputs = /* @__PURE__ */ new Set();
+	const pendingInputs = /* @__PURE__ */ new Set();
+	let failed = false;
+	let platformRequestId;
+	let active;
+	let rejectStart;
+	let timer;
+	const recorded = /* @__PURE__ */ new Set();
+	let writes = Promise.resolve();
+	let cancellationPending = false;
+	let inputQueue = [];
+	let queuedInputBytes = 0;
+	let uploadingBytes = 0;
+	let uploadTimer;
+	const send = (type, fields = {}) => {
+		if (closed || socket?.readyState !== WebSocket.OPEN) throw new Error("Omni connection is closed");
+		socket.send(JSON.stringify({
+			type,
+			event_id: crypto.randomUUID(),
+			...fields
+		}));
+	};
+	function pumpInput() {
+		if (closed || failed || uploadingBytes || muted || clearingInput) return;
+		const bytes = inputQueue.shift();
+		if (!bytes) return;
+		queuedInputBytes -= bytes.length;
+		uploadingBytes = bytes.length;
+		uploadTimer = setTimeout(() => fail("OMNI_UPLOAD_TIMEOUT"), UPLOAD_TIMEOUT_MS);
+		try {
+			if (socket?.readyState !== WebSocket.OPEN) throw new Error("Omni connection is closed");
+			socket.send(JSON.stringify({
+				type: "input_audio_buffer.append",
+				event_id: crypto.randomUUID(),
+				audio: bytes.toString("base64")
+			}), (error) => {
+				clearTimeout(uploadTimer);
+				uploadingBytes = 0;
+				if (closed || failed) return;
+				if (error) {
+					fail("OMNI_CONNECTION_FAILED");
+					return;
+				}
+				pumpInput();
+			});
+		} catch {
+			clearTimeout(uploadTimer);
+			fail("OMNI_CONNECTION_FAILED");
+		}
+	}
+	const save = (entry) => {
+		if (!entry.text.trim() || recorded.has(entry.itemId)) return;
+		if (recorded.size >= 1e4) {
+			fail("OMNI_ITEM_LIMIT");
+			return;
+		}
+		recorded.add(entry.itemId);
+		writes = writes.then(() => options.record(entry)).catch((err) => {
+			log.warn({
+				err,
+				sessionId: options.callId
+			}, "Native voice transcript write failed");
+			fail("TRANSCRIPT_WRITE_FAILED");
+		});
+	};
+	const cancel = (reason) => {
+		const response = active;
+		if (!response) return false;
+		active = void 0;
+		response.abort.abort(reason);
+		save({
+			itemId: response.id,
+			role: "assistant",
+			text: response.text,
+			interrupted: true
+		});
+		options.send("response.cancelled", {
+			responseId: response.id,
+			reason
+		});
+		if (reason === "client_cancelled" && response.generating && socket?.readyState === WebSocket.OPEN) {
+			cancellationPending = true;
+			send("response.cancel");
+		}
+		return true;
+	};
+	const finish = async (response) => {
+		await response.tail;
+		if (active !== response || closed) return;
+		await response.playback.drain(response.abort.signal);
+		if (active !== response || closed) return;
+		save({
+			itemId: response.id,
+			role: "assistant",
+			text: response.text,
+			interrupted: false
+		});
+		options.send("response.audio.done", { responseId: response.id });
+		options.send("response.done", {
+			responseId: response.id,
+			audio: response.audio,
+			finishReason: response.audio ? "completed" : "text_only"
+		});
+		active = void 0;
+	};
+	const stopReply = (response, code) => {
+		if (closed || active !== response) return;
+		log.warn({
+			sessionId: options.callId,
+			platformRequestId,
+			responseId: response.id,
+			code,
+			queuedBytes: response.queuedBytes
+		}, "Native voice reply stopped; call remains connected");
+		cancel("client_cancelled");
+		options.send("session.error", {
+			code: "RESPONSE_FAILED",
+			message: "Voice playback could not keep up. This reply was stopped; you can continue speaking.",
+			recoverable: true
+		});
+	};
+	function fail(code, details = {}) {
+		if (closed || failed) return;
+		failed = true;
+		log.warn({
+			sessionId: options.callId,
+			platformRequestId,
+			responseId: active?.id,
+			code,
+			provider: options.route.route.provider,
+			upstreamHost: new URL(options.route.url).hostname,
+			queuedInputBytes,
+			uploadingBytes,
+			bufferedAmount: socket?.bufferedAmount,
+			...details
+		}, `Native voice conversation failed: ${code}`);
+		rejectStart?.(new Error(code));
+		const reference = platformRequestId ?? options.callId;
+		options.send("session.error", {
+			code,
+			message: `${FAILURE_MESSAGES[code] ?? "Natural conversation failed."} (${code}; reference: ${reference})`,
+			recoverable: false
+		});
+		options.onClose("omni_error", true);
+	}
+	function discardInput() {
+		inputQueue = [];
+		queuedInputBytes = 0;
+		inputBlocked = true;
+		if (clearingInput) return;
+		clearingInput = true;
+		clearTimer = setTimeout(() => fail("OMNI_INPUT_RESET_TIMEOUT"), uploadingBytes ? UPLOAD_TIMEOUT_MS + 5e3 : 5e3);
+		for (const id of pendingInputs) discardedInputs.add(id);
+		pendingInputs.clear();
+		if (discardedInputs.size > 1e4) {
+			fail("OMNI_ITEM_LIMIT");
+			return;
+		}
+		send("input_audio_buffer.clear");
+	}
+	const engine = {
+		start() {
+			return new Promise((resolve, reject) => {
+				rejectStart = reject;
+				socket = new WebSocket(options.route.url, {
+					headers: { Authorization: `Bearer ${options.route.apiKey}` },
+					maxPayload: 1024 * 1024,
+					perMessageDeflate: false,
+					handshakeTimeout: 15e3
+				});
+				socket.on("upgrade", (response) => {
+					const id = response.headers["x-xopc-request-id"];
+					if (typeof id === "string" && /^[a-zA-Z0-9-]{1,160}$/.test(id)) platformRequestId = id;
+					log.info({
+						sessionId: options.callId,
+						platformRequestId,
+						model: options.route.route.model,
+						provider: options.route.route.provider
+					}, "Native voice upstream connected");
+				});
+				timer = setTimeout(() => {
+					fail("OMNI_START_TIMEOUT");
+					engine.close();
+				}, 15e3);
+				socket.on("error", () => fail("OMNI_CONNECTION_FAILED"));
+				socket.on("close", (closeCode) => {
+					if (!closed) fail("OMNI_CONNECTION_CLOSED", { closeCode });
+				});
+				socket.on("unexpected-response", (_request, response) => {
+					response.resume();
+					fail("OMNI_CONNECTION_REJECTED", { upstreamStatus: response.statusCode });
+				});
+				socket.on("message", (raw, binary) => {
+					if (closed) return;
+					try {
+						if (binary) throw new Error("Unexpected Omni binary frame");
+						const event = JSON.parse(raw.toString());
+						if (event.type === "error") {
+							if (cancellationPending && event.error?.type === "invalid_request_error" && event.error?.message === "Conversation has none active response") {
+								cancellationPending = false;
+								return;
+							}
+							fail("OMNI_PROVIDER_ERROR");
+							return;
+						}
+						if (event.type === "session.created") send("session.update", { session: {
+							modalities: ["text", "audio"],
+							voice: options.route.voice,
+							instructions: options.route.instructions,
+							input_audio_format: "pcm",
+							output_audio_format: "pcm",
+							input_audio_transcription: { model: "gummy-realtime-v1" },
+							turn_detection: {
+								type: "server_vad",
+								threshold: .5,
+								silence_duration_ms: options.silenceDurationMs,
+								create_response: true,
+								interrupt_response: options.bargeIn
+							}
+						} });
+						else if (event.type === "session.updated" && !ready) {
+							ready = true;
+							clearTimeout(timer);
+							rejectStart = void 0;
+							resolve();
+						} else if (event.type === "input_audio_buffer.cleared") {
+							clearingInput = false;
+							clearTimeout(clearTimer);
+						} else if (event.type === "input_audio_buffer.speech_started") {
+							if (muted || clearingInput) {
+								discardedInputs.add(String(event.item_id));
+								return;
+							}
+							inputBlocked = false;
+							pendingInputs.add(String(event.item_id));
+							if (options.bargeIn) cancel("barge_in");
+							options.send("input.speech_started", { utteranceId: String(event.item_id) });
+						} else if (event.type === "input_audio_buffer.speech_stopped") {
+							if (muted || inputBlocked || discardedInputs.has(String(event.item_id))) return;
+							options.send("input.speech_stopped", { utteranceId: String(event.item_id) });
+						} else if (event.type === "conversation.item.input_audio_transcription.completed") {
+							if (typeof event.transcript !== "string" || event.transcript.length > 32e3 || typeof event.item_id !== "string") {
+								fail("OMNI_INVALID_TRANSCRIPT");
+								return;
+							}
+							if (muted || inputBlocked || discardedInputs.has(event.item_id) || recorded.has(event.item_id)) return;
+							pendingInputs.delete(event.item_id);
+							save({
+								itemId: event.item_id,
+								role: "user",
+								text: event.transcript,
+								interrupted: false
+							});
+							options.send("input.transcript.final", {
+								utteranceId: event.item_id,
+								revision: 1,
+								text: event.transcript
+							});
+						} else if (event.type === "response.created") {
+							if (muted || inputBlocked) {
+								cancellationPending = true;
+								send("response.cancel");
+								return;
+							}
+							cancellationPending = false;
+							if (active) cancel("barge_in");
+							const id = event.response?.id;
+							if (typeof id !== "string" || !id.length || id.length > 160) throw new Error("Invalid response ID");
+							active = {
+								id,
+								text: "",
+								audio: false,
+								generating: true,
+								queuedBytes: 0,
+								abort: new AbortController(),
+								playback: new AudioPlaybackWindow(),
+								tail: Promise.resolve()
+							};
+							options.send("response.created", { responseId: id });
+						} else if (active && event.response_id === active.id && event.type === "response.audio_transcript.delta") {
+							if (typeof event.delta !== "string" || active.text.length + event.delta.length > 32e3) {
+								fail("OMNI_TRANSCRIPT_LIMIT");
+								return;
+							}
+							active.text += event.delta;
+							options.send("response.text.delta", {
+								responseId: active.id,
+								delta: event.delta
+							});
+						} else if (active && event.response_id === active.id && event.type === "response.audio.delta") {
+							if (typeof event.delta !== "string" || !/^[A-Za-z0-9+/]*={0,2}$/.test(event.delta)) {
+								fail("OMNI_INVALID_AUDIO");
+								return;
+							}
+							const audio = Buffer.from(event.delta, "base64");
+							if (!audio.length || audio.length % 2) {
+								fail("OMNI_INVALID_AUDIO");
+								return;
+							}
+							const response = active;
+							if (response.queuedBytes + audio.length > MAX_QUEUED_AUDIO_BYTES) {
+								stopReply(response, "OMNI_OUTPUT_BACKPRESSURE");
+								return;
+							}
+							response.queuedBytes += audio.length;
+							response.tail = response.tail.then(async () => {
+								for (let offset = 0; offset < audio.length; offset += 24e3) {
+									if (closed || active !== response) return;
+									const chunk = audio.subarray(offset, offset + 24e3);
+									await response.playback.reserve(chunk.length, response.abort.signal);
+									if (closed || active !== response) return;
+									if (!response.audio) {
+										response.audio = true;
+										options.send("response.audio.started", {
+											responseId: response.id,
+											format: {
+												encoding: "pcm_s16le",
+												channels: 1,
+												sampleRate: 24e3
+											}
+										});
+									}
+									options.sendAudio(response.id, chunk);
+								}
+							}).catch(() => {
+								if (!response.abort.signal.aborted) stopReply(response, "OMNI_PLAYBACK_FAILED");
+							}).finally(() => {
+								response.queuedBytes -= audio.length;
+							});
+						} else if (event.type === "response.done" && active?.id === event.response?.id) {
+							active.generating = false;
+							if (event.response.status === "cancelled") cancel("barge_in");
+							else if (event.response.status !== "completed") fail("OMNI_RESPONSE_FAILED");
+							else {
+								const response = active;
+								options.send("response.text.done", { responseId: response.id });
+								finish(response).catch(() => {
+									if (!response.abort.signal.aborted) stopReply(response, "OMNI_PLAYBACK_FAILED");
+								});
+							}
+						}
+					} catch {
+						fail("OMNI_PROTOCOL_ERROR");
+					}
+				});
+			});
+		},
+		setInputMuted(next) {
+			muted = next;
+			if (next) discardInput();
+		},
+		appendAudio(bytes) {
+			if (closed || failed || muted || clearingInput) return;
+			if (!ready || !bytes.length || bytes.length % 2 || bytes.length > 64 * 1024) throw new Error("Invalid Omni input");
+			if (queuedInputBytes + uploadingBytes + bytes.length > MAX_PENDING_INPUT_BYTES) {
+				log.warn({
+					sessionId: options.callId,
+					provider: options.route.route.provider,
+					upstreamHost: new URL(options.route.url).hostname,
+					queuedInputBytes,
+					uploadingBytes,
+					bufferedAmount: socket?.bufferedAmount
+				}, "Native voice input discarded after upload congestion; call remains connected");
+				discardInput();
+				options.send("session.error", {
+					code: "INPUT_DROPPED",
+					message: "The voice connection is slow. This microphone input was discarded; please repeat it once the connection recovers.",
+					recoverable: true
+				});
+				return;
+			}
+			for (let offset = 0; offset < bytes.length; offset += 24e3) {
+				const chunk = Buffer.from(bytes.subarray(offset, offset + 24e3));
+				inputQueue.push(chunk);
+				queuedInputBytes += chunk.length;
+			}
+			pumpInput();
+		},
+		async commit() {
+			throw new Error("Natural conversation uses automatic turn detection");
+		},
+		cancel(responseId, reason) {
+			if (active?.id !== responseId) return false;
+			if (reason === "client_cancelled") discardInput();
+			return cancel(reason);
+		},
+		acknowledge(responseId, playedBytes) {
+			if (active?.id === responseId) active.playback.acknowledge(playedBytes);
+		},
+		close() {
+			if (closed) return writes;
+			closed = true;
+			cancel("session_closed");
+			clearTimeout(timer);
+			clearTimeout(clearTimer);
+			clearTimeout(uploadTimer);
+			inputQueue = [];
+			queuedInputBytes = 0;
+			rejectStart?.(/* @__PURE__ */ new Error("Omni connection closed"));
+			rejectStart = void 0;
+			socket?.terminate();
+			return writes;
+		}
+	};
+	return engine;
+}
+//#endregion
+export { createOmniVoiceEngine };

package/dist/src/voice/realtime/omniRoute.d.ts

@@ -0,0 +1,10 @@
+import type { VoiceProviderRoute } from '@xopcai/realtime-protocol/voice';
+import type { Config } from '../../config/schema.js';
+export interface OmniRoute {
+    route: VoiceProviderRoute;
+    url: string;
+    apiKey: string;
+    voice: string;
+    instructions: string;
+}
+export declare function resolveOmniRoute(config: Config): Promise<OmniRoute>;

package/dist/src/voice/realtime/omniRoute.js

@@ -0,0 +1,31 @@
+import { init_xopc_cloud_config, resolveXopcModelRouterUrl } from "../../providers/xopc-cloud-config.js";
+import { getProviderAuthService, init_provider_auth_service } from "../../providers/provider-auth-service.js";
+//#region src/voice/realtime/omniRoute.ts
+init_provider_auth_service();
+init_xopc_cloud_config();
+async function resolveOmniRoute(config) {
+	const slice = config.voice?.realtime?.omni;
+	if (!slice) throw new Error("Natural conversation is not configured");
+	if (slice.model !== "qwen3-omni-flash-realtime") throw new Error("This Omni model has not been certified");
+	const managed = slice.provider === "xopc-cloud";
+	const url = new URL(managed ? `${resolveXopcModelRouterUrl(slice.baseUrl)}/audio/conversations/realtime` : slice.baseUrl ?? "wss://dashscope.aliyuncs.com/api-ws/v1/realtime");
+	if (managed && url.protocol === "https:") url.protocol = "wss:";
+	if (url.protocol !== "wss:" || url.username || url.password || url.hash || url.port) throw new Error("Omni requires a secure WebSocket endpoint");
+	if (!managed && (!(new Set(["dashscope.aliyuncs.com", "dashscope-intl.aliyuncs.com"]).has(url.hostname) || /^[a-zA-Z0-9-]+\.(cn-beijing|ap-southeast-1)\.maas\.aliyuncs\.com$/.test(url.hostname)) || url.pathname !== "/api-ws/v1/realtime")) throw new Error("Unsupported DashScope realtime endpoint");
+	const apiKey = managed ? await getProviderAuthService().resolveApiKey("xopc-cloud") : slice.apiKey ?? config.tools?.media?.audio?.providers?.alibaba?.apiKey ?? await getProviderAuthService().resolveApiKey("dashscope");
+	if (!apiKey) throw new Error("Omni credentials are unavailable");
+	url.search = new URLSearchParams({ model: slice.model }).toString();
+	return {
+		route: {
+			provider: slice.provider,
+			model: slice.model,
+			managed
+		},
+		url: url.toString(),
+		apiKey,
+		voice: slice.voice,
+		instructions: slice.instructions
+	};
+}
+//#endregion
+export { resolveOmniRoute };