@xopcai/xopc 0.0.368 → 0.0.369

package/dist/src/voice/dashscope/streaming-tts-stream.js

@@ -47,6 +47,18 @@ function event(type, extra = {}) {
 	});
 }
 async function openDashScopeStreamingTts(request) {
+	const session = await openDashScopeTtsSession(request);
+	try {
+		return {
+			...await session.synthesize(request.text),
+			release: () => session.close()
+		};
+	} catch (error) {
+		await session.close();
+		throw error;
+	}
+}
+async function openDashScopeTtsSession(request) {
 	const volume = request.volume ?? DEFAULT_REALTIME_VOLUME;
 	if (!Number.isInteger(volume) || volume < 0 || volume > 100) throw new Error("DashScope realtime TTS volume must be an integer from 0 to 100");
 	request = {
@@ -79,58 +91,48 @@ async function openDashScopeStreamingTts(request) {
 }
 async function openStreamingTtsAttempt(request) {
 	if (!request.apiKey) throw new Error("DashScope TTS API key is unavailable");
-	if (request.signal.aborted) throw request.signal.reason;
+	request.signal.throwIfAborted();
+	const startedAt = Date.now();
 	const socket = new WebSocket(realtimeUrl(request.baseUrl, request.model), {
 		headers: { Authorization: `Bearer ${request.apiKey}` },
 		perMessageDeflate: false
 	});
-	let controller;
 	let settled = false;
-	let streamClosed = false;
+	let closed = false;
+	let failure;
+	let active;
 	let resolveReady;
 	let rejectReady;
-	const readyPromise = new Promise((resolve, reject) => {
+	const ready = new Promise((resolve, reject) => {
 		resolveReady = resolve;
 		rejectReady = reject;
 	});
-	const audioStream = new ReadableStream({
-		start(next) {
-			controller = next;
-		},
-		cancel() {
-			streamClosed = true;
-			socket.close(1e3, "Consumer cancelled");
-		}
-	});
-	const fail = (error, closeSocket = true) => {
+	const closeSocket = (code, reason) => {
+		request.signal.removeEventListener("abort", onAbort);
+		if (socket.readyState === WebSocket.OPEN) socket.close(code, reason);
+		else if (socket.readyState === WebSocket.CONNECTING) socket.terminate();
+	};
+	const fail = (error, code = 1011) => {
+		if (closed) return;
+		failure = error;
+		closed = true;
 		if (!settled) rejectReady(error);
-		if (!streamClosed) {
-			streamClosed = true;
-			controller?.error(error);
-		}
-		if (closeSocket) {
-			if (socket.readyState === WebSocket.OPEN) socket.close(1011, "Provider stream failed");
-			else if (socket.readyState === WebSocket.CONNECTING) socket.terminate();
+		if (active) {
+			clearTimeout(active.timer);
+			if (!active.audioDone) active.controller.error(error);
+			active.reject(error);
 		}
+		closeSocket(code, code === 1e3 ? "Aborted" : "Provider stream failed");
 	};
-	const finishStream = () => {
-		if (streamClosed) return;
-		streamClosed = true;
-		controller?.close();
-	};
-	const onAbort = () => {
-		fail(request.signal.reason instanceof Error ? request.signal.reason : new DOMException("Realtime TTS aborted", "AbortError"), false);
-		if (socket.readyState === WebSocket.OPEN) socket.close(1e3, "Aborted");
-		else if (socket.readyState === WebSocket.CONNECTING) socket.terminate();
-	};
+	const onAbort = () => fail(request.signal.reason instanceof Error ? request.signal.reason : new DOMException("Realtime TTS aborted", "AbortError"), 1e3);
 	request.signal.addEventListener("abort", onAbort, { once: true });
+	if (request.signal.aborted) onAbort();
 	socket.on("unexpected-response", (_request, response) => {
 		fail(new TtsHandshakeError(response.statusCode ?? 0, parseRetryAfter(response.headers["retry-after"])));
 		response.destroy();
 	});
 	socket.on("message", (data, isBinary) => {
-		if (streamClosed || request.signal.aborted) return;
-		if (isBinary) return;
+		if (closed || isBinary) return;
 		let message;
 		try {
 			message = JSON.parse(rawText(data));
@@ -138,43 +140,54 @@ async function openStreamingTtsAttempt(request) {
 			fail(/* @__PURE__ */ new Error("DashScope realtime TTS returned invalid JSON"));
 			return;
 		}
-		if (message.type === "session.created") {
-			socket.send(event("session.update", { session: {
-				voice: request.voice,
-				mode: "commit",
-				language_type: "Auto",
-				response_format: "pcm",
-				sample_rate: 24e3,
-				volume: request.volume,
-				...request.instructions ? {
-					instructions: request.instructions,
-					optimize_instructions: false
-				} : {}
-			} }));
-			return;
-		}
-		if (message.type === "session.updated") {
+		if (message.type === "session.created") socket.send(event("session.update", { session: {
+			voice: request.voice,
+			mode: "commit",
+			language_type: "Auto",
+			response_format: "pcm",
+			sample_rate: 24e3,
+			volume: request.volume,
+			...request.instructions ? {
+				instructions: request.instructions,
+				optimize_instructions: false
+			} : {}
+		} }));
+		else if (message.type === "session.updated" && !settled) {
 			settled = true;
+			log.info({
+				model: request.model,
+				phase: "tts_connection_ready",
+				setupMs: Date.now() - startedAt
+			}, "Realtime TTS connection ready");
 			resolveReady();
-			socket.send(event("input_text_buffer.append", { text: request.text }));
-			socket.send(event("input_text_buffer.commit"));
-			return;
-		}
-		if (message.type === "response.audio.delta") {
-			if (streamClosed) return;
+		} else if (message.type === "response.audio.delta" && active && !active.audioDone) {
 			if (typeof message.delta !== "string") {
 				fail(/* @__PURE__ */ new Error("DashScope realtime TTS returned invalid audio"));
 				return;
 			}
-			controller?.enqueue(Buffer.from(message.delta, "base64"));
-			return;
-		}
-		if (message.type === "response.audio.done") {
-			finishStream();
-			socket.send(event("session.finish"));
-			return;
-		}
-		if (message.type === "error") {
+			const bytes = Buffer.from(message.delta, "base64");
+			if (!bytes.byteLength) return;
+			if (!active.firstAudio) {
+				active.firstAudio = true;
+				log.info({
+					model: request.model,
+					phase: "tts_first_audio",
+					synthesisMs: Date.now() - active.submittedAt
+				}, "Realtime TTS first audio received");
+			}
+			active.controller.enqueue(bytes);
+		} else if (message.type === "response.audio.done" && active && !active.audioDone) {
+			active.audioDone = true;
+			active.controller.close();
+		} else if (message.type === "response.done" && active) {
+			if (!active.audioDone) {
+				active.audioDone = true;
+				active.controller.close();
+			}
+			clearTimeout(active.timer);
+			active.resolve();
+			active = void 0;
+		} else if (message.type === "error") {
 			const code = typeof message.error?.code === "string" ? message.error.code : void 0;
 			const detail = typeof message.error?.message === "string" ? message.error.message : void 0;
 			fail(new Error([code, detail].filter(Boolean).join(": ") || "DashScope realtime TTS failed"));
@@ -183,28 +196,71 @@ async function openStreamingTtsAttempt(request) {
 	socket.on("error", (error) => fail(error));
 	socket.on("close", () => {
 		request.signal.removeEventListener("abort", onAbort);
-		if (!streamClosed) fail(/* @__PURE__ */ new Error("DashScope realtime TTS connection closed unexpectedly"));
+		if (!closed) fail(/* @__PURE__ */ new Error("DashScope realtime TTS connection closed unexpectedly"));
 	});
-	const timeout = setTimeout(() => {
-		fail(/* @__PURE__ */ new Error("DashScope realtime TTS setup timed out"));
-		socket.close(1011, "Setup timeout");
-	}, request.timeoutMs);
+	const timeout = setTimeout(() => fail(/* @__PURE__ */ new Error("DashScope realtime TTS setup timed out")), request.timeoutMs);
 	try {
-		await readyPromise;
+		await ready;
 	} finally {
 		clearTimeout(timeout);
 	}
 	return {
-		audioStream,
-		outputFormat: "pcm",
-		fileExtension: "pcm",
-		voiceCompatible: false,
-		release: async () => {
-			request.signal.removeEventListener("abort", onAbort);
-			finishStream();
-			if (socket.readyState === WebSocket.OPEN) socket.close(1e3, "Released");
+		async synthesize(text) {
+			request.signal.throwIfAborted();
+			if (closed) throw failure ?? /* @__PURE__ */ new Error("Realtime TTS session closed");
+			if (active) throw new Error("Realtime TTS synthesis already active");
+			let resolve;
+			let reject;
+			const done = new Promise((yes, no) => {
+				resolve = yes;
+				reject = no;
+			});
+			done.catch(() => {});
+			const audioStream = new ReadableStream({
+				start(controller) {
+					active = {
+						controller,
+						audioDone: false,
+						done,
+						resolve,
+						reject,
+						submittedAt: Date.now(),
+						firstAudio: false,
+						timer: setTimeout(() => fail(/* @__PURE__ */ new Error("Realtime TTS synthesis timed out")), request.timeoutMs)
+					};
+				},
+				cancel() {
+					fail(new DOMException("Realtime TTS consumer cancelled", "AbortError"), 1e3);
+				}
+			});
+			socket.send(event("input_text_buffer.append", { text }));
+			socket.send(event("input_text_buffer.commit"));
+			return {
+				audioStream,
+				outputFormat: "pcm",
+				fileExtension: "pcm",
+				voiceCompatible: false,
+				release: async () => {
+					await done;
+				}
+			};
+		},
+		async close() {
+			if (closed) return;
+			if (active && !active.audioDone) {
+				fail(new DOMException("Realtime TTS session released", "AbortError"), 1e3);
+				return;
+			}
+			if (active) {
+				clearTimeout(active.timer);
+				active.resolve();
+				active = void 0;
+			}
+			closed = true;
+			if (socket.readyState === WebSocket.OPEN) socket.send(event("session.finish"));
+			closeSocket(1e3, "Released");
 		}
 	};
 }
 //#endregion
-export { openDashScopeStreamingTts };
+export { openDashScopeStreamingTts, openDashScopeTtsSession };

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

@@ -1,6 +1,6 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { speakStream } from "../tts/speak-core.js";
+import { prepareSpeechStreamSession, speakStream } from "../tts/speak-core.js";
 import { AudioPlaybackWindow } from "./audio-playback-window.js";
 import { TurnCoordinator } from "./turnPolicy.js";
 import { PlaybackEchoCandidates } from "./playback-echo.js";
@@ -12,6 +12,7 @@ init_logger();
 const log = createLogger("Voice:Agent");
 const AGENT_TTS_MAX_SEGMENT_CHARACTERS = 180;
 const AGENT_TTS_MIN_SEGMENT_CHARACTERS = 24;
+const FIRST_PHRASE_WAIT_MS = 300;
 const PLAYBACK_ECHO_TAIL_MS = 3e3;
 const TASK_UPDATE_QUIET_MS = 1500;
 function createAgentVoiceEngine(options) {
@@ -101,6 +102,7 @@ function createAgentVoiceEngine(options) {
 			expiresAt: Date.now() + PLAYBACK_ECHO_TAIL_MS
 		};
 		activeResponse = void 0;
+		clearTimeout(response.firstPhraseTimer);
 		response.abortController.abort(reason);
 		send("response.cancelled", {
 			responseId: response.id,
@@ -124,6 +126,42 @@ function createAgentVoiceEngine(options) {
 	}
 	function openSpeech(response, job) {
 		if (job.opening) return job.opening;
+		if (response.firstSynthesisAtMs === void 0) {
+			response.firstSynthesisAtMs = Date.now();
+			log.info({
+				sessionId: claim.sessionId,
+				responseId: response.id,
+				conversationId: claim.request.conversationId,
+				phase: "first_synthesis_requested",
+				textToSynthesisMs: response.firstTextAtMs === void 0 ? void 0 : response.firstSynthesisAtMs - response.firstTextAtMs
+			}, "Realtime voice first synthesis requested");
+		}
+		if (response.preparedSpeech) {
+			job.opening = response.preparedSpeech.then(async (prepared) => {
+				if ("error" in prepared) return prepared;
+				response.abortController.signal.throwIfAborted();
+				if (response.firstSubmitAtMs === void 0) {
+					response.firstSubmitAtMs = Date.now();
+					log.info({
+						sessionId: claim.sessionId,
+						responseId: response.id,
+						conversationId: claim.request.conversationId,
+						phase: "first_tts_text_submitted",
+						phraseToSubmitMs: response.firstPhraseAtMs === void 0 ? void 0 : response.firstSubmitAtMs - response.firstPhraseAtMs
+					}, "Realtime voice first TTS text submitted");
+				}
+				const result = await prepared.session.synthesize(job.phrase);
+				return { result: {
+					...result,
+					provider: claim.tts.config.provider,
+					release: result.release ?? (async () => {}),
+					ttsText: job.phrase,
+					wasPreprocessed: false,
+					wasSummarized: false
+				} };
+			}).catch((error) => ({ error }));
+			return job.opening;
+		}
 		job.opening = speakStream(job.phrase, claim.tts.config, {
 			appConfig: claim.config,
 			parseDirectives: false,
@@ -133,6 +171,7 @@ function createAgentVoiceEngine(options) {
 		return job.opening;
 	}
 	function prefetchNextSpeech(response) {
+		if (response.preparedSpeech) return;
 		const next = response.speechQueue[0];
 		if (!next || next.opening || response.abortController.signal.aborted) return;
 		openSpeech(response, next);
@@ -165,6 +204,9 @@ function createAgentVoiceEngine(options) {
 						phase: "first_response_audio",
 						latencyMs: Date.now() - response.startedAt,
 						inputToAudioMs: Date.now() - response.inputReceivedAtMs,
+						submitToAudioMs: response.firstSubmitAtMs === void 0 ? void 0 : Date.now() - response.firstSubmitAtMs,
+						synthesisToAudioMs: response.firstSynthesisAtMs === void 0 ? void 0 : Date.now() - response.firstSynthesisAtMs,
+						phraseToAudioMs: response.firstPhraseAtMs === void 0 ? void 0 : Date.now() - response.firstPhraseAtMs,
 						textToAudioMs: response.firstTextAtMs === void 0 ? void 0 : Date.now() - response.firstTextAtMs
 					}, "Realtime voice first audio ready");
 					send("response.audio.started", {
@@ -233,6 +275,18 @@ function createAgentVoiceEngine(options) {
 	function queuePhrases(response, phrases) {
 		for (const phrase of phrases) {
 			if (response.speechError || response.abortController.signal.aborted) return;
+			if (response.firstPhraseAtMs === void 0) {
+				response.firstPhraseAtMs = Date.now();
+				clearTimeout(response.firstPhraseTimer);
+				log.info({
+					sessionId: claim.sessionId,
+					responseId: response.id,
+					conversationId: claim.request.conversationId,
+					phase: "first_speech_phrase",
+					characters: phrase.length,
+					textToPhraseMs: response.firstTextAtMs === void 0 ? void 0 : response.firstPhraseAtMs - response.firstTextAtMs
+				}, "Realtime voice first speech phrase ready");
+			}
 			if (response.queuedSpeechCharacters + phrase.length > 8e3) {
 				response.speechError = /* @__PURE__ */ new Error("Voice synthesis queue limit reached");
 				return;
@@ -275,6 +329,21 @@ function createAgentVoiceEngine(options) {
 		activeResponse = response;
 		send("response.created", { responseId: response.id });
 		try {
+			const opening = prepareSpeechStreamSession(claim.tts.config, {
+				appConfig: claim.config,
+				signal: response.abortController.signal,
+				allowFallback: false
+			});
+			if (opening) response.preparedSpeech = opening.then((session) => {
+				log.info({
+					sessionId: claim.sessionId,
+					responseId: response.id,
+					conversationId: claim.request.conversationId,
+					phase: "response_tts_ready",
+					setupMs: Date.now() - response.startedAt
+				}, "Realtime voice TTS prepared");
+				return { session };
+			}, (error) => ({ error }));
 			await interruptionWrites;
 			if (response.abortController.signal.aborted || closed) return taskUpdateExposed();
 			if (!claim.conversationSessionId) throw new Error("Conversation identity is unavailable");
@@ -320,6 +389,10 @@ function createAgentVoiceEngine(options) {
 						delta: event.payload.delta
 					});
 					queuePhrases(response, response.segmenter.push(event.payload.delta));
+					if (response.firstPhraseAtMs === void 0 && response.firstPhraseTimer === void 0) response.firstPhraseTimer = setTimeout(() => {
+						response.firstPhraseTimer = void 0;
+						if (activeResponse === response && !response.abortController.signal.aborted) queuePhrases(response, response.segmenter.flushFirstPhrase());
+					}, FIRST_PHRASE_WAIT_MS);
 				}
 				if (event.type === "tool_start") queuePhrases(response, response.segmenter.flush());
 				if ((event.type === "tool_start" || event.type === "tool_end") && typeof event.payload?.toolCallId === "string" && typeof event.payload?.toolName === "string") send("task.activity", {
@@ -410,7 +483,11 @@ function createAgentVoiceEngine(options) {
 			if (activeResponse === response) activeResponse = void 0;
 			return taskUpdateExposed();
 		} finally {
+			clearTimeout(response.firstPhraseTimer);
 			await waitForSpeech(response);
+			response.abortController.abort("response_finished");
+			const prepared = await response.preparedSpeech;
+			if (prepared && "session" in prepared) await prepared.session.close();
 		}
 	}
 	async function openSttSession(consumed) {

package/dist/src/voice/realtime/speakable-segmenter.d.ts

@@ -8,6 +8,8 @@ export declare class SpeakableSegmenter {
     private emitted;
     constructor(maxCharacters?: number, minCharacters?: number, firstMinCharacters?: number);
     push(delta: string): string[];
+    /** Releases only a complete short phrase; never cuts a word or Markdown construct. */
+    flushFirstPhrase(): string[];
     flush(): string[];
     private toSpeech;
 }

package/dist/src/voice/realtime/speakable-segmenter.js

@@ -80,6 +80,36 @@ var SpeakableSegmenter = class {
 		}
 		return phrases;
 	}
+	/** Releases only a complete short phrase; never cuts a word or Markdown construct. */
+	flushFirstPhrase() {
+		if (this.emitted || this.fence || /^\s*(```|~~~|\|)/.test(this.pending)) return [];
+		let brackets = 0;
+		let parentheses = 0;
+		let inlineCode = false;
+		for (let index = 0; index < this.pending.length; index += 1) {
+			if (/^https?:\/\//.test(this.pending.slice(index))) {
+				const end = this.pending.slice(index).search(/\s/);
+				if (end < 0) return [];
+				index += end - 1;
+				continue;
+			}
+			const char = this.pending[index];
+			if (char === "`") inlineCode = !inlineCode;
+			if (char === "[") brackets += 1;
+			if (char === "]") brackets = Math.max(0, brackets - 1);
+			if (char === "(") parentheses += 1;
+			if (char === ")") parentheses = Math.max(0, parentheses - 1);
+			if (inlineCode || brackets || parentheses) continue;
+			if (index >= 11 && /[，、,\s]/u.test(char)) {
+				const phrase = this.toSpeech(this.pending.slice(0, index + 1));
+				if (!phrase) continue;
+				this.pending = this.pending.slice(index + 1);
+				this.emitted = true;
+				return [phrase];
+			}
+		}
+		return [];
+	}
 	flush() {
 		const phrase = this.fence || /^\s*(```|~~~)/.test(this.pending) ? "" : this.toSpeech(this.pending);
 		this.pending = "";

package/dist/src/voice/tts/providers/alibaba-speech.js

@@ -4,7 +4,7 @@ import { ProviderHttpError } from "../../../media-shared/http/provider-http-erro
 import { fetchWithTimeoutGuarded, postJsonRequest } from "../../../media-shared/http/provider-http.js";
 import "../../../media-shared/http/index.js";
 import { registerSpeechProvider } from "../speech-registry.js";
-import { openDashScopeStreamingTts } from "../../dashscope/streaming-tts-stream.js";
+import { openDashScopeStreamingTts, openDashScopeTtsSession } from "../../dashscope/streaming-tts-stream.js";
 import { alibabaVoicesForModel } from "./alibaba-voices.js";
 //#region src/voice/tts/providers/alibaba-speech.ts
 /**
@@ -154,6 +154,22 @@ const alibabaSpeechProvider = {
 			voiceCompatible: false
 		};
 	},
+	openStreamSession: async (req) => {
+		const config = readProviderConfig(req.providerConfig);
+		const apiKey = resolveApiKey(config);
+		if (!apiKey) throw new Error("Alibaba TTS API key missing");
+		const overrides = req.providerOverrides ?? {};
+		const instructions = trimToUndefined(overrides.instructions);
+		return openDashScopeTtsSession({
+			apiKey,
+			baseUrl: config.baseUrl,
+			model: ALIBABA_REALTIME_TTS_MODEL,
+			voice: trimToUndefined(overrides.voice ?? overrides.voiceId) ?? config.voice,
+			...instructions ? { instructions } : {},
+			signal: req.signal,
+			timeoutMs: req.timeoutMs
+		});
+	},
 	synthesizeStream: async (req) => {
 		const config = readProviderConfig(req.providerConfig);
 		const apiKey = resolveApiKey(config);

package/dist/src/voice/tts/speak-core.d.ts

@@ -16,6 +16,7 @@
  */
 import type { Config } from '../../config/schema.js';
 import { type PreprocessOptions } from './preprocess.js';
+import type { SpeechStreamSession } from './speech-provider-types.js';
 import type { TTSConfig, TTSModelOverrideConfig, TTSOptions, TTSProvider, TTSResultWithTracking } from './types.js';
 export interface SpeakOptions {
     tts?: TTSOptions;
@@ -56,3 +57,5 @@ export interface SpeakStreamResult {
  * Providers without `synthesizeStream` are wrapped via wrapBufferAsStream.
  */
 export declare function speakStream(text: string, config: TTSConfig, options?: SpeakStreamOptions): Promise<SpeakStreamResult>;
+/** Prepares a single frozen route while the Agent is generating its first text. */
+export declare function prepareSpeechStreamSession(config: TTSConfig, options: SpeakStreamOptions): Promise<SpeechStreamSession> | undefined;

package/dist/src/voice/tts/speak-core.js

@@ -292,5 +292,25 @@ function wrapBufferAsStream(result) {
 		voiceCompatible: result.voiceCompatible
 	};
 }
+/** Prepares a single frozen route while the Agent is generating its first text. */
+function prepareSpeechStreamSession(config, options) {
+	options.signal?.throwIfAborted();
+	if (!config.enabled) return void 0;
+	const resolved = resolveSpeechProvider(config.provider, config);
+	if (!resolved?.plugin.openStreamSession) return void 0;
+	const sessionRequest = {
+		...buildSynthesisRequest(resolved, "", options.tts, void 0, options.appConfig, "voice-note", options.signal),
+		signal: options.signal ?? new AbortController().signal
+	};
+	return resolved.plugin.openStreamSession(sessionRequest).then((session) => ({
+		close: () => session.close(),
+		synthesize: (text) => session.synthesize(preprocessText(text, {
+			maxLength: config.maxTextLength || 4096,
+			stripMarkdown: true,
+			normalizeWhitespace: true,
+			...options.preprocess
+		}).text)
+	}));
+}
 //#endregion
-export { speak, speakStream, speakWithProvider };
+export { prepareSpeechStreamSession, speak, speakStream, speakWithProvider };

package/dist/src/voice/tts/speech-provider-types.d.ts

@@ -89,6 +89,12 @@ export interface SpeechSynthesisRequest {
     signal: AbortSignal;
 }
 export type SpeechSynthesisStreamRequest = SpeechSynthesisRequest;
+/** A prepared connection owned by one reply; syntheses must be consumed in order. */
+export interface SpeechStreamSession {
+    synthesize(text: string): Promise<SpeechSynthesisStreamResult>;
+    close(): Promise<void>;
+}
+export type SpeechStreamSessionRequest = Omit<SpeechSynthesisStreamRequest, 'text'>;
 /** Voice catalog entry returned by `listVoices`. */
 export interface SpeechVoiceOption {
     id: string;
@@ -154,6 +160,8 @@ export interface SpeechProviderPlugin {
      * + `wrapBufferAsStream` (single-chunk stream). See speak-core §8.1.
      */
     synthesizeStream?(req: SpeechSynthesisStreamRequest): Promise<SpeechSynthesisStreamResult>;
+    /** Optional connection preparation and reuse for live conversation replies. */
+    openStreamSession?(req: SpeechStreamSessionRequest): Promise<SpeechStreamSession>;
     /** Voice discovery for Web UI / CLI. Optional; orchestrator returns [] when missing. */
     listVoices?(req: SpeechListVoicesRequest): Promise<SpeechVoiceOption[]>;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xopcai/xopc",
-  "version": "0.0.368",
+  "version": "0.0.369",
   "description": "Local-first personal AI for the one-person company, with durable context, tasks, workflows, automations, and local or cloud models.",
   "type": "module",
   "main": "dist/src/index.js",
@@ -167,8 +167,8 @@
     "@xopcai/endpoint-tools-protocol": "0.0.0",
     "@xopcai/gateway-contract": "0.0.0",
     "@xopcai/realtime-client": "0.0.0",
-    "@xopcai/image-providers": "0.1.0",
-    "@xopcai/realtime-protocol": "0.0.0"
+    "@xopcai/realtime-protocol": "0.0.0",
+    "@xopcai/image-providers": "0.1.0"
   },
   "scripts": {
     "assets:brand": "node scripts/generate-brand-assets.mjs",