@xopcai/xopc 0.0.286 → 0.0.291

package/dist/src/tui/backends/embedded-backend.js

@@ -6,9 +6,9 @@ import { getSessionMetadata } from "../../storage/sqlite/session-repository.js";
 import "../../storage/sqlite/index.js";
 import { getAgentDefaultModelRef, init_schema } from "../../config/schema.js";
 import { init_agent_scope, listAgentEntries, normalizeAgentId } from "../../agent/agent-scope.js";
+import { loadConfig, saveConfig } from "../../config/loader.js";
 import { createConversation, init_conversation_repository } from "../../storage/sqlite/conversation-repository.js";
 import { init_agent_session_key, resolveAgentIdFromConversationId } from "../../routing/agent-session-key.js";
-import { loadConfig, saveConfig } from "../../config/loader.js";
 import { effectiveWorkspacePathForSession } from "../../session/session-workspace.js";
 import { ProjectService } from "../../projects/project-service.js";
 import { inferSuggestedProjectDefaultAgentId } from "../../projects/project-agent-suggestion.js";

package/dist/src/tui/tui-commands.js

@@ -1,9 +1,9 @@
 import { closeXopcDatabase, isXopcDatabaseOpen, openXopcDatabase } from "../storage/sqlite/connection.js";
 import { getSessionMetadata } from "../storage/sqlite/session-repository.js";
 import "../storage/sqlite/index.js";
-import { init_agent_session_key, isValidAgentId, normalizeAgentId } from "../routing/agent-session-key.js";
 import { resolveConfigPath } from "../config/paths.js";
 import { loadConfig } from "../config/loader.js";
+import { init_agent_session_key, isValidAgentId, normalizeAgentId } from "../routing/agent-session-key.js";
 import { init_providers, providerSupportsOAuth } from "../providers/index.js";
 import { TaskRepository } from "../tasks/task-repository.js";
 import { ProjectService } from "../projects/project-service.js";

package/dist/src/tui/tui-startup-resources.js

@@ -1,6 +1,6 @@
 import { resolveStateDir } from "../config/paths-state.js";
-import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
 import { init_paths, resolveAgentProfileDir, resolveBundledSkillsDir } from "../config/paths.js";
+import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
 import { resolveBootstrapFilesSync } from "../agent/bootstrap/bootstrap-files.js";
 import { createSkillConfigManager, isSkillEnabled } from "../agent/skills/config.js";
 import { loadSkills } from "../agent/skills/index.js";

package/dist/src/tui/tui.js

@@ -1,10 +1,10 @@
 import { version } from "../../package.js";
 import { resolveStateDir, resolveXopcDatabasePath } from "../config/paths-state.js";
-import { init_agent_session_key, normalizeAgentId } from "../routing/agent-session-key.js";
-import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
 import { init_paths } from "../config/paths.js";
 import { loadConfig } from "../config/loader.js";
+import { init_agent_session_key, normalizeAgentId } from "../routing/agent-session-key.js";
 import { getAllModels, getAllProviders, getApiKey, init_providers, isProviderConfiguredSync } from "../providers/index.js";
+import { resolveEffectiveAgentProfileForSession } from "../config/agent-profile.js";
 import { ProjectTrustStore, hasTrustRequiringProjectResources } from "../project-trust/trust-store.js";
 import { MAX_WEBCHAT_ATTACHMENT_FILE_BYTES } from "../gateway/chat-limits.js";
 import { renderWorkflowFinalSummary, renderWorkflowPanel } from "../agent/workflow/snapshot.js";

package/dist/src/voice/platform-catalog.d.ts

@@ -0,0 +1,81 @@
+import type { VoiceModeCapability } from '@xopcai/realtime-protocol/voice';
+export declare function platformVoiceModels(mode: VoiceModeCapability): import("../providers/model-catalog-types.js").CatalogModel[];
+export declare function requirePlatformVoiceModel(id: string, mode: VoiceModeCapability): {
+    voice: {
+        protocolVersion: 1;
+        serviceVersion: number;
+        modes: ("conversation" | "transcription" | "speech" | "transcription.stream" | "speech.stream")[];
+        transport: "websocket-pcm";
+        inputFormat: {
+            encoding: "pcm_s16le";
+            sampleRate: 16000;
+            channels: 1;
+        };
+        outputFormat: {
+            encoding: "pcm_s16le";
+            sampleRate: 24000;
+            channels: 1;
+        };
+        turnDetection: "server_vad"[];
+        bargeIn: boolean;
+        tools: boolean;
+        resumable: false;
+        voices: {
+            id: string;
+            name: string;
+            languages: string[];
+        }[];
+        limits: {
+            maxFrameBytes: number;
+            maxSessionSeconds: number;
+        };
+        defaultVoice?: string;
+    };
+    computerUse?: {
+        profile: "gui-plus-2026-02-26" | "structured-tools-v1";
+    };
+    id: string;
+    name: string;
+    displayNames?: Partial<Record<"zh-CN" | "en", string>>;
+    availability: "available" | "unavailable";
+    kind: "language" | "image" | "stt" | "tts" | "omni";
+    input: Array<"text" | "image" | "audio">;
+    output: Array<"text" | "image" | "audio">;
+    operations: Array<"chat.completions" | "responses" | "images.generate" | "images.edit" | "audio.transcription" | "audio.speech" | "audio.conversation">;
+    reasoning: boolean;
+    contextWindow: number;
+    maxOutputTokens: number | null;
+    stability?: "stable" | "preview" | "deprecated";
+    priority?: number;
+    tier?: string;
+    bestEffort?: boolean;
+    imageGeneration?: {
+        maxCount: number;
+        sizes: string[];
+        aspectRatios?: string[];
+        qualities: Array<"low" | "medium" | "high" | "auto">;
+        formats: Array<"png" | "jpeg" | "webp">;
+        backgrounds: Array<"transparent" | "opaque" | "auto">;
+        maxInputImages: number;
+    };
+    stt?: {
+        inputFormats: string[];
+        maxBytes: number;
+        maxDurationSeconds: number;
+        languages: string[];
+        languageHint: boolean;
+        prompt: boolean;
+        timestamps: Array<"segment" | "word">;
+        diarization: boolean;
+    };
+    tts?: {
+        maxCharacters: number;
+        languages: string[];
+        outputFormats: Array<"mp3" | "opus" | "aac" | "flac" | "wav" | "pcm">;
+        streaming: boolean;
+        speed: boolean;
+        pitch: boolean;
+        instructions: boolean;
+        defaultVoice?: string;
+    };
+};

package/dist/src/voice/platform-catalog.js

@@ -0,0 +1,16 @@
+import { getModelCatalogStore, init_model_catalog_store } from "../providers/model-catalog-store.js";
+//#region src/voice/platform-catalog.ts
+init_model_catalog_store();
+function platformVoiceModels(mode) {
+	return (getModelCatalogStore().getSource("xopc-cloud")?.models ?? []).filter((model) => model.availability === "available" && model.voice?.modes.includes(mode));
+}
+function requirePlatformVoiceModel(id, mode) {
+	const model = platformVoiceModels(mode).find((model) => model.id === id);
+	if (!model?.voice) throw new Error(`Published voice model is unavailable for ${mode}: ${id}`);
+	return {
+		...model,
+		voice: model.voice
+	};
+}
+//#endregion
+export { platformVoiceModels, requirePlatformVoiceModel };

package/dist/src/voice/platform-settings.d.ts

@@ -0,0 +1,4 @@
+import type { VoiceSelection, VoiceSettingsCatalog } from '@xopcai/realtime-protocol/voice';
+import { type Config } from '../config/schema.js';
+export declare function voiceSettingsCatalog(config: Config): VoiceSettingsCatalog;
+export declare function selectPlatformVoice(config: Config, selection: VoiceSelection): Config;

package/dist/src/voice/platform-settings.js

@@ -0,0 +1,120 @@
+import { ConfigSchema, init_schema } from "../config/schema.js";
+import { getModelCatalogStore, init_model_catalog_store } from "../providers/model-catalog-store.js";
+import { requirePlatformVoiceModel } from "./platform-catalog.js";
+import { createHash } from "node:crypto";
+//#region src/voice/platform-settings.ts
+init_schema();
+init_model_catalog_store();
+function voiceSettingsCatalog(config) {
+	const source = getModelCatalogStore().getSource("xopc-cloud");
+	const selections = [];
+	const add = (mode, slice) => {
+		if (slice?.provider === "xopc-cloud" && slice.model) selections.push({
+			mode,
+			model: slice.model,
+			...slice.voice ? { voice: slice.voice } : {}
+		});
+	};
+	const audio = config.tools?.media?.audio;
+	const tts = config.messages?.tts;
+	add("transcription", {
+		...audio?.providers?.["xopc-cloud"],
+		provider: audio?.provider
+	});
+	add("speech", {
+		...tts?.providers?.["xopc-cloud"],
+		provider: tts?.provider
+	});
+	add("transcription.stream", config.voice?.realtime?.stt);
+	add("speech.stream", config.voice?.realtime?.tts);
+	add("conversation", config.voice?.realtime?.omni);
+	return {
+		revision: createHash("sha256").update(JSON.stringify([
+			config.voice,
+			audio,
+			tts
+		])).digest("hex"),
+		catalogVersion: source?.etag ?? null,
+		selections,
+		models: (source?.models ?? []).flatMap((model) => model.availability === "available" && model.voice ? [{
+			id: model.id,
+			name: model.name,
+			voice: model.voice
+		}] : [])
+	};
+}
+function selectPlatformVoice(config, selection) {
+	const model = requirePlatformVoiceModel(selection.model, selection.mode);
+	const output = selection.mode === "speech" || selection.mode === "speech.stream" || selection.mode === "conversation";
+	const voice = selection.voice ?? model.voice.defaultVoice ?? model.voice.voices[0]?.id;
+	if (output && (!voice || !model.voice.voices.some((item) => item.id === voice))) throw new Error("Choose an available model voice");
+	const next = structuredClone(config);
+	const selected = {
+		provider: "xopc-cloud",
+		model: selection.model,
+		...output ? { voice } : {}
+	};
+	if (selection.mode === "transcription") {
+		next.tools.media ??= {};
+		const audio = next.tools.media.audio ?? {
+			enabled: true,
+			provider: "xopc-cloud",
+			fallback: {
+				enabled: false,
+				order: []
+			},
+			providers: {}
+		};
+		next.tools.media.audio = {
+			...audio,
+			enabled: true,
+			provider: "xopc-cloud",
+			providers: {
+				...audio.providers,
+				"xopc-cloud": {
+					...audio.providers?.["xopc-cloud"],
+					model: selection.model
+				}
+			}
+		};
+	} else if (selection.mode === "speech") {
+		next.messages ??= {};
+		const tts = next.messages.tts ?? {
+			enabled: true,
+			provider: "xopc-cloud",
+			trigger: "off",
+			maxTextLength: 4e3,
+			timeoutMs: 3e4,
+			providers: {}
+		};
+		next.messages.tts = {
+			...tts,
+			enabled: true,
+			provider: "xopc-cloud",
+			providers: {
+				...tts.providers,
+				"xopc-cloud": {
+					...tts.providers?.["xopc-cloud"],
+					model: selection.model,
+					voice
+				}
+			}
+		};
+	} else {
+		next.voice = ConfigSchema.parse({
+			...next,
+			voice: next.voice ?? {}
+		}).voice;
+		next.voice.realtime.enabled = true;
+		if (selection.mode === "transcription.stream") next.voice.realtime.stt = selected;
+		if (selection.mode === "speech.stream") next.voice.realtime.tts = selected;
+		if (selection.mode === "conversation") next.voice.realtime.omni = {
+			...selected,
+			voice,
+			instructions: next.voice.realtime.omni?.instructions ?? "Keep replies conversational and concise. You cannot execute tools."
+		};
+	}
+	return ConfigSchema.parse(next);
+}
+//#endregion
+export { selectPlatformVoice, voiceSettingsCatalog };

package/dist/src/voice/platform-streams.d.ts

@@ -0,0 +1,12 @@
+import type { StreamingSttOpenRequest, StreamingSttSession } from '../media-understanding/types.js';
+import type { SpeechSynthesisStreamResult } from './tts/speech-provider-types.js';
+export declare function openPlatformStt(request: StreamingSttOpenRequest): Promise<StreamingSttSession>;
+export declare function openPlatformTts(request: {
+    baseUrl: string;
+    apiKey: string;
+    voice: string;
+    text: string;
+    instructions?: string;
+    signal: AbortSignal;
+    timeoutMs: number;
+}): Promise<SpeechSynthesisStreamResult>;

package/dist/src/voice/platform-streams.js

@@ -0,0 +1,250 @@
+import WebSocket from "ws";
+//#region src/voice/platform-streams.ts
+const MAX_BUFFERED_BYTES = 512 * 1024;
+function connect(url, token, signal, onEvent, onFailure) {
+	signal.throwIfAborted();
+	const socket = new WebSocket(url, {
+		headers: { Authorization: `Bearer ${token}` },
+		perMessageDeflate: false,
+		maxPayload: 1024 * 1024
+	});
+	let ended = false;
+	const close = () => {
+		if (ended) return;
+		ended = true;
+		signal.removeEventListener("abort", abort);
+		if (socket.readyState === WebSocket.OPEN) socket.close();
+		else if (socket.readyState === WebSocket.CONNECTING) socket.terminate();
+	};
+	const fail = (error) => {
+		if (!ended) {
+			onFailure(error);
+			close();
+		}
+	};
+	const abort = () => fail(signal.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("Voice request aborted"));
+	signal.addEventListener("abort", abort, { once: true });
+	socket.on("message", (raw, binary) => {
+		if (ended) return;
+		try {
+			if (binary) throw new Error("Unexpected platform binary event");
+			const event = JSON.parse(raw.toString());
+			if (!event || typeof event.type !== "string") throw new Error("Invalid platform voice event");
+			if (event.type === "error") throw new Error(event.error?.message ?? "Platform voice failed");
+			onEvent(event);
+		} catch (error) {
+			fail(error instanceof Error ? error : /* @__PURE__ */ new Error("Invalid platform voice event"));
+		}
+	});
+	socket.on("unexpected-response", (_request, response) => {
+		response.resume();
+		fail(/* @__PURE__ */ new Error(`Platform voice rejected connection (${response.statusCode})`));
+	});
+	socket.on("error", fail);
+	socket.on("close", () => fail(/* @__PURE__ */ new Error("Platform voice disconnected before completion")));
+	return {
+		socket,
+		close,
+		fail,
+		send: (value) => {
+			if (ended || socket.readyState !== WebSocket.OPEN) throw new Error("Platform voice is not connected");
+			if (socket.bufferedAmount > MAX_BUFFERED_BYTES) throw new Error("Platform voice backpressure limit exceeded");
+			socket.send(value instanceof Uint8Array ? value : JSON.stringify(value));
+		}
+	};
+}
+async function openPlatformStt(request) {
+	if (!request.apiKey || !request.baseUrl) throw new Error("Platform authorization is unavailable");
+	if (request.inputFormat.sampleRate !== 16e3 || request.inputFormat.encoding !== "pcm_s16le" || request.inputFormat.channels !== 1) throw new Error("Platform STT requires 16 kHz mono PCM16");
+	let ready = false, finished = false, finishing = false;
+	let failure;
+	let inputBytes = 0;
+	const sentences = /* @__PURE__ */ new Map();
+	let resolveReady, rejectReady, resolveFinished;
+	const readyPromise = new Promise((resolve, reject) => {
+		resolveReady = resolve;
+		rejectReady = reject;
+	});
+	const finishedPromise = new Promise((resolve) => {
+		resolveFinished = resolve;
+	});
+	const connection = connect(request.baseUrl, request.apiKey, request.signal, (event) => {
+		if (event.type === "session.updated") {
+			if (event.session?.input_sample_rate !== 16e3) throw new Error("Unsupported STT audio format");
+			ready = true;
+			resolveReady();
+			request.onEvent({ type: "ready" });
+		} else if (event.type === "transcript.partial" || event.type === "transcript.final") {
+			if (!ready || typeof event.item_id !== "string" || typeof event.text !== "string") throw new Error("Invalid platform transcript");
+			let sentence = sentences.get(event.item_id);
+			if (sentence?.final) return;
+			if (!sentence) {
+				if (sentences.size >= 1e4) throw new Error("Transcript limit exceeded");
+				sentence = {
+					revision: 0,
+					final: false
+				};
+				sentences.set(event.item_id, sentence);
+				request.onEvent({
+					type: "speech_started",
+					utteranceId: event.item_id
+				});
+			}
+			sentence.revision++;
+			if (event.type === "transcript.final") {
+				sentence.final = true;
+				request.onEvent({
+					type: "speech_stopped",
+					utteranceId: event.item_id
+				});
+				request.onEvent({
+					type: "transcript_final",
+					utteranceId: event.item_id,
+					revision: sentence.revision,
+					text: event.text
+				});
+			} else request.onEvent({
+				type: "transcript_delta",
+				utteranceId: event.item_id,
+				revision: sentence.revision,
+				text: event.text
+			});
+		} else if (event.type === "session.finished") {
+			finished = true;
+			request.onEvent({
+				type: "usage",
+				inputAudioMs: Math.round(inputBytes / 32)
+			});
+			resolveFinished();
+			connection.close();
+		}
+	}, (error) => {
+		failure = error;
+		rejectReady(error);
+		resolveFinished();
+		request.onEvent({
+			type: "error",
+			error
+		});
+	});
+	connection.socket.once("open", () => connection.send({
+		type: "session.update",
+		session: { ...request.language ? { language: request.language } : {} }
+	}));
+	const timer = setTimeout(() => connection.fail(/* @__PURE__ */ new Error("Platform STT setup timed out")), request.timeoutMs);
+	try {
+		await readyPromise;
+	} finally {
+		clearTimeout(timer);
+	}
+	const commit = async () => {
+		if (failure) throw failure;
+		if (!finished && !finishing) {
+			finishing = true;
+			connection.send({ type: "session.finish" });
+		}
+		const timeout = setTimeout(() => connection.fail(/* @__PURE__ */ new Error("Platform STT finalization timed out")), request.timeoutMs);
+		try {
+			await finishedPromise;
+			if (failure) throw failure;
+		} finally {
+			clearTimeout(timeout);
+			connection.close();
+		}
+	};
+	return {
+		appendAudio(bytes) {
+			if (!ready || finished || finishing || failure) throw new Error("Platform STT is not writable");
+			if (!bytes.length || bytes.length % 2 || bytes.length > 65536) throw new Error("Invalid PCM frame");
+			inputBytes += bytes.length;
+			connection.send(bytes);
+		},
+		commit,
+		close: commit,
+		abort() {
+			finished = true;
+			resolveFinished();
+			connection.close();
+		}
+	};
+}
+async function openPlatformTts(request) {
+	let controller;
+	let resolveReady, rejectReady;
+	let ready = false, ended = false, finishSent = false;
+	const readyPromise = new Promise((resolve, reject) => {
+		resolveReady = resolve;
+		rejectReady = reject;
+	});
+	const stream = new ReadableStream({
+		start(value) {
+			controller = value;
+		},
+		cancel() {
+			ended = true;
+			clearTimeout(timer);
+			connection.close();
+		}
+	}, {
+		highWaterMark: MAX_BUFFERED_BYTES,
+		size: (chunk) => chunk.byteLength
+	});
+	const connection = connect(request.baseUrl, request.apiKey, request.signal, (event) => {
+		if (event.type === "session.updated" && !ready) {
+			if (event.session?.output_sample_rate !== 24e3) throw new Error("Unsupported TTS audio format");
+			ready = true;
+			resolveReady();
+			const characters = [...request.text];
+			for (let i = 0; i < characters.length; i += 1e3) connection.send({
+				type: "input_text_buffer.append",
+				text: characters.slice(i, i + 1e3).join("")
+			});
+			connection.send({ type: "input_text_buffer.commit" });
+		} else if ((event.type === "response.done" || event.type === "text.flushed") && !finishSent) {
+			finishSent = true;
+			connection.send({ type: "session.finish" });
+		} else if (event.type === "response.audio.delta") {
+			if (!ready || typeof event.delta !== "string" || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(event.delta)) throw new Error("Invalid platform audio");
+			const bytes = Buffer.from(event.delta, "base64");
+			if (bytes.length % 2 || (controller.desiredSize ?? 0) < bytes.length) throw new Error("Platform TTS audio buffer exceeded");
+			controller.enqueue(bytes);
+		} else if (event.type === "session.finished") {
+			ended = true;
+			clearTimeout(timer);
+			controller.close();
+			connection.close();
+		}
+	}, (error) => {
+		rejectReady(error);
+		if (!ended) {
+			ended = true;
+			controller.error(error);
+		}
+		clearTimeout(timer);
+	});
+	const timer = setTimeout(() => connection.fail(/* @__PURE__ */ new Error("Platform TTS timed out")), request.timeoutMs);
+	connection.socket.once("open", () => connection.send({
+		type: "session.update",
+		session: {
+			voice: request.voice,
+			...request.instructions ? { instructions: request.instructions } : {}
+		}
+	}));
+	await readyPromise;
+	return {
+		audioStream: stream,
+		outputFormat: "pcm",
+		fileExtension: "pcm",
+		voiceCompatible: false,
+		release: async () => {
+			clearTimeout(timer);
+			connection.close();
+			if (!ended) {
+				ended = true;
+				controller.close();
+			}
+		}
+	};
+}
+//#endregion
+export { openPlatformStt, openPlatformTts };

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

@@ -143,7 +143,7 @@ function createOmniVoiceEngine(options) {
 				reason
 			});
 		}
-		if ((reason === "client_cancelled" || reason === "barge_in" && !options.bargeIn) && response.generating && socket?.readyState === WebSocket.OPEN) {
+		if ((reason === "client_cancelled" || reason === "barge_in" && (options.route.route.managed || !options.bargeIn)) && response.generating && socket?.readyState === WebSocket.OPEN) {
 			cancellationPending = true;
 			send("response.cancel");
 		}
@@ -286,7 +286,7 @@ function createOmniVoiceEngine(options) {
 						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") {
+							if (!options.route.route.managed && cancellationPending && event.error?.type === "invalid_request_error" && event.error?.message === "Conversation has none active response") {
 								cancellationPending = false;
 								return;
 							}
@@ -297,9 +297,11 @@ function createOmniVoiceEngine(options) {
 							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" },
+							...!options.route.route.managed ? {
+								input_audio_format: "pcm",
+								output_audio_format: "pcm",
+								input_audio_transcription: { model: "gummy-realtime-v1" }
+							} : {},
 							turn_detection: {
 								type: "server_vad",
 								threshold: .5,
@@ -309,6 +311,7 @@ function createOmniVoiceEngine(options) {
 							}
 						} });
 						else if (event.type === "session.updated" && !ready) {
+							if (options.route.route.managed && (event.session?.input_sample_rate !== 16e3 || event.session?.output_sample_rate !== 24e3)) throw new Error("Unsupported platform audio format");
 							ready = true;
 							clearTimeout(timer);
 							rejectStart = void 0;

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

@@ -6,5 +6,6 @@ export interface OmniRoute {
     apiKey: string;
     voice: string;
     instructions: string;
+    maxSessionSeconds?: number;
 }
 export declare function resolveOmniRoute(config: Config): Promise<OmniRoute>;

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

@@ -1,12 +1,20 @@
 import { init_xopc_cloud_config, resolveXopcModelRouterUrl } from "../../providers/xopc-cloud-config.js";
 import { getProviderAuthService, init_provider_auth_service } from "../../providers/provider-auth-service.js";
+import { requirePlatformVoiceModel } from "../platform-catalog.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");
+	let maxSessionSeconds;
+	let serviceVersion;
+	if (slice.provider === "xopc-cloud") {
+		const model = requirePlatformVoiceModel(slice.model, "conversation");
+		maxSessionSeconds = model.voice.limits.maxSessionSeconds;
+		serviceVersion = model.voice.serviceVersion;
+		if (!model.voice.voices.some((voice) => voice.id === slice.voice)) throw new Error("Selected voice is unavailable");
+	}
 	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:";
@@ -15,7 +23,9 @@ async function resolveOmniRoute(config) {
 	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();
+	if (serviceVersion) url.searchParams.set("service_version", String(serviceVersion));
 	return {
+		maxSessionSeconds,
 		route: {
 			provider: slice.provider,
 			model: slice.model,