@xopcai/xopc 0.0.242 → 0.0.243

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

@@ -0,0 +1,153 @@
+import { createRequire } from "node:module";
+import crypto from "node:crypto";
+//#region src/voice/dashscope/streaming-tts-stream.ts
+const { WebSocket } = createRequire(import.meta.url)("ws");
+const DEFAULT_REALTIME_URL = "wss://dashscope.aliyuncs.com/api-ws/v1/realtime";
+function realtimeUrl(baseUrl, model) {
+	const configured = baseUrl ? new URL(baseUrl) : new URL(DEFAULT_REALTIME_URL);
+	const wasWebSocket = configured.protocol === "ws:" || configured.protocol === "wss:";
+	configured.protocol = configured.protocol === "http:" ? "ws:" : configured.protocol === "https:" ? "wss:" : configured.protocol;
+	if (configured.protocol !== "ws:" && configured.protocol !== "wss:") throw new Error("DashScope realtime TTS base URL must use HTTP or WebSocket");
+	if (!wasWebSocket) configured.pathname = "/api-ws/v1/realtime";
+	configured.searchParams.set("model", model);
+	return configured.toString();
+}
+function rawText(data) {
+	if (typeof data === "string") return data;
+	if (data instanceof ArrayBuffer) return Buffer.from(data).toString("utf8");
+	if (Array.isArray(data)) return Buffer.concat(data).toString("utf8");
+	return data.toString("utf8");
+}
+function event(type, extra = {}) {
+	return JSON.stringify({
+		event_id: crypto.randomUUID(),
+		type,
+		...extra
+	});
+}
+async function openDashScopeStreamingTts(request) {
+	if (!request.apiKey) throw new Error("DashScope TTS API key is unavailable");
+	if (request.signal.aborted) throw request.signal.reason;
+	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 resolveReady;
+	let rejectReady;
+	const readyPromise = 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) => {
+		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();
+		}
+	};
+	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();
+	};
+	request.signal.addEventListener("abort", onAbort, { once: true });
+	socket.on("message", (data, isBinary) => {
+		if (streamClosed || request.signal.aborted) return;
+		if (isBinary) return;
+		let message;
+		try {
+			message = JSON.parse(rawText(data));
+		} catch {
+			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,
+				...request.instructions ? {
+					instructions: request.instructions,
+					optimize_instructions: false
+				} : {}
+			} }));
+			return;
+		}
+		if (message.type === "session.updated") {
+			settled = true;
+			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;
+			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 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"));
+		}
+	});
+	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"));
+	});
+	const timeout = setTimeout(() => {
+		fail(/* @__PURE__ */ new Error("DashScope realtime TTS setup timed out"));
+		socket.close(1011, "Setup timeout");
+	}, request.timeoutMs);
+	try {
+		await readyPromise;
+	} 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");
+		}
+	};
+}
+//#endregion
+export { openDashScopeStreamingTts };

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

@@ -0,0 +1,10 @@
+import type { VoiceTicketClaim, VoiceRealtimeRuntimeOptions } from './runtime.js';
+import type { VoiceEngine, VoiceEventSink } from './engine.js';
+export declare function createAgentVoiceEngine(options: {
+    claim: VoiceTicketClaim;
+    runtime: VoiceRealtimeRuntimeOptions;
+    signal: AbortSignal;
+    send: VoiceEventSink;
+    sendAudio: (responseId: string, bytes: Uint8Array) => void;
+    onClose: (reason: string, notify: boolean) => Promise<void>;
+}): VoiceEngine;

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

@@ -0,0 +1,403 @@
+import { createLogger } from "../../utils/logger/index.js";
+import { init_logger } from "../../utils/logger.js";
+import { speakStream } from "../tts/speak-core.js";
+import { AudioPlaybackWindow } from "./audio-playback-window.js";
+import { SpeakableSegmenter } from "./speakable-segmenter.js";
+import crypto from "node:crypto";
+//#region src/voice/realtime/agentEngine.ts
+init_logger();
+const log = createLogger("Voice:Agent");
+function createAgentVoiceEngine(options) {
+	const claim = options.claim;
+	const stt = claim.stt;
+	if (!stt) throw new Error("Agent voice requires a transcription route");
+	const send = options.send;
+	let closed = false;
+	let sttSession;
+	let activeResponse;
+	let conversationTail = Promise.resolve();
+	let interruptionWrites = Promise.resolve();
+	let closing;
+	let queuedTurns = 0;
+	let inputGeneration = 0;
+	let muted = false;
+	let sttGeneration = 0;
+	let sttAbort = new AbortController();
+	let inputReset;
+	let bufferedAudio = [];
+	let bufferedBytes = 0;
+	let finalCount = 0;
+	let committing = false;
+	const finalizedUtterances = /* @__PURE__ */ new Set();
+	function cancelActiveResponse(reason) {
+		const response = activeResponse;
+		if (!response) return false;
+		activeResponse = void 0;
+		response.abortController.abort(reason);
+		send("response.cancelled", {
+			responseId: response.id,
+			reason
+		});
+		const sessionKey = claim.request.sessionKey;
+		if (sessionKey && reason !== "session_closed") interruptionWrites = interruptionWrites.then(() => options.runtime.recordInterruption({
+			sessionKey,
+			responseId: response.id,
+			reason,
+			generatedCharacters: response.text.length,
+			interruptedDuring: response.audioStarted ? "speaking" : "thinking"
+		})).catch((error) => {
+			log.warn({
+				err: error,
+				sessionId: claim.sessionId,
+				responseId: response.id
+			}, "Voice interruption audit failed");
+		});
+		return true;
+	}
+	async function speakPhrase(response, phrase) {
+		if (!claim.tts || response.abortController.signal.aborted) return;
+		const result = await speakStream(phrase, claim.tts.config, {
+			appConfig: claim.config,
+			parseDirectives: false,
+			signal: response.abortController.signal,
+			allowFallback: false
+		});
+		try {
+			if (response.abortController.signal.aborted || activeResponse !== response || closed) return;
+			if (result.outputFormat !== "pcm") throw new Error(`Realtime TTS returned unsupported format: ${result.outputFormat}`);
+			const reader = result.audioStream.getReader();
+			while (true) {
+				const item = await reader.read();
+				if (item.done) break;
+				if (response.abortController.signal.aborted || activeResponse !== response) return;
+				if (!response.audioStarted) {
+					response.audioStarted = true;
+					log.info({
+						sessionId: claim.sessionId,
+						responseId: response.id,
+						latencyMs: Date.now() - response.startedAt
+					}, "Realtime voice first audio ready");
+					send("response.audio.started", {
+						responseId: response.id,
+						format: {
+							encoding: "pcm_s16le",
+							sampleRate: 24e3,
+							channels: 1
+						}
+					});
+				}
+				for (let offset = 0; offset < item.value.byteLength; offset += 24e3) {
+					const chunk = item.value.subarray(offset, offset + 24e3);
+					await response.playback.reserve(chunk.byteLength, response.abortController.signal);
+					if (activeResponse !== response || closed) return;
+					options.sendAudio(response.id, chunk);
+				}
+			}
+		} finally {
+			await result.release();
+		}
+	}
+	function queuePhrases(response, phrases) {
+		for (const phrase of phrases) {
+			if (response.speechError || response.abortController.signal.aborted) return;
+			if (response.queuedSpeechCharacters + phrase.length > 8e3) {
+				response.speechError = /* @__PURE__ */ new Error("Voice synthesis queue limit reached");
+				return;
+			}
+			response.queuedSpeechCharacters += phrase.length;
+			response.speechTail = response.speechTail.then(async () => {
+				if (response.speechError || response.abortController.signal.aborted) return;
+				try {
+					await speakPhrase(response, phrase);
+				} catch (error) {
+					if (!response.abortController.signal.aborted) response.speechError = error instanceof Error ? error : new Error(String(error));
+				}
+			}).finally(() => {
+				response.queuedSpeechCharacters -= phrase.length;
+			});
+		}
+	}
+	async function runConversationTurn(text) {
+		if (!claim.tts || !claim.request.sessionKey || !text.trim() || closed) return;
+		cancelActiveResponse("barge_in");
+		const response = {
+			id: `resp_${crypto.randomUUID()}`,
+			playback: new AudioPlaybackWindow(),
+			abortController: new AbortController(),
+			segmenter: new SpeakableSegmenter(),
+			text: "",
+			audioStarted: false,
+			speechTail: Promise.resolve(),
+			queuedSpeechCharacters: 0,
+			startedAt: Date.now(),
+			firstTextSeen: false,
+			awaitingClarification: false
+		};
+		activeResponse = response;
+		send("response.created", { responseId: response.id });
+		try {
+			await interruptionWrites;
+			if (response.abortController.signal.aborted || closed) return;
+			for await (const event of options.runtime.runAgent(text, claim.request.sessionKey, response.abortController.signal)) {
+				if (activeResponse !== response || response.abortController.signal.aborted) return;
+				if (event.type === "assistant_delta" || event.type === "tool_end") response.awaitingClarification = false;
+				if (event.type === "assistant_delta" && typeof event.payload?.delta === "string") {
+					if (response.text.length + event.payload.delta.length > 32e3) throw new Error("Voice response text limit reached");
+					if (!response.firstTextSeen) {
+						response.firstTextSeen = true;
+						log.info({
+							sessionId: claim.sessionId,
+							responseId: response.id,
+							latencyMs: Date.now() - response.startedAt
+						}, "Realtime voice first response text ready");
+					}
+					response.text += event.payload.delta;
+					send("response.text.delta", {
+						responseId: response.id,
+						delta: event.payload.delta
+					});
+					queuePhrases(response, response.segmenter.push(event.payload.delta));
+				}
+				if ((event.type === "tool_start" || event.type === "tool_end") && typeof event.payload?.toolCallId === "string" && typeof event.payload?.toolName === "string") send("response.activity", {
+					responseId: response.id,
+					toolCallId: event.payload.toolCallId.slice(0, 160),
+					toolName: event.payload.toolName.slice(0, 256),
+					status: event.type === "tool_start" ? "running" : event.payload.status === "error" ? "failed" : "completed"
+				});
+				if (event.type === "clarify_request" && typeof event.payload?.requestId === "string" && typeof event.payload?.question === "string") {
+					response.awaitingClarification = true;
+					send("response.clarification", {
+						responseId: response.id,
+						requestId: event.payload.requestId.slice(0, 160),
+						question: event.payload.question.slice(0, 8e3),
+						...Array.isArray(event.payload.choices) ? { choices: event.payload.choices.filter((choice) => typeof choice === "string").slice(0, 20).map((choice) => choice.slice(0, 1e3)) } : {}
+					});
+				}
+				if (event.type === "error") throw new Error(typeof event.payload?.message === "string" ? event.payload.message : "Agent response failed");
+			}
+			if (activeResponse !== response || response.abortController.signal.aborted || closed) return;
+			queuePhrases(response, response.segmenter.flush());
+			send("response.text.done", { responseId: response.id });
+			await response.speechTail;
+			if (response.speechError) throw response.speechError;
+			await response.playback.drain(response.abortController.signal);
+			if (activeResponse !== response || response.abortController.signal.aborted) return;
+			if (response.audioStarted) send("response.audio.done", { responseId: response.id });
+			send("response.done", {
+				responseId: response.id,
+				finishReason: response.audioStarted ? "completed" : "text_only",
+				audio: response.audioStarted
+			});
+			activeResponse = void 0;
+		} catch (error) {
+			if (response.abortController.signal.aborted || closed) return;
+			log.warn({
+				err: error,
+				sessionId: claim.sessionId,
+				responseId: response.id
+			}, "Realtime voice response failed");
+			send("session.error", {
+				code: "RESPONSE_FAILED",
+				message: "Voice response failed",
+				recoverable: true
+			});
+			if (response.audioStarted) send("response.audio.done", { responseId: response.id });
+			send("response.done", {
+				responseId: response.id,
+				finishReason: response.audioStarted ? "audio_partial" : "text_only",
+				audio: response.audioStarted
+			});
+			response.abortController.abort("provider_error");
+			if (activeResponse === response) activeResponse = void 0;
+		} finally {
+			await response.speechTail;
+		}
+	}
+	async function openSttSession(consumed) {
+		const generation = sttGeneration;
+		return stt.plugin.openAudioStream({
+			model: stt.model,
+			inputFormat: {
+				encoding: "pcm_s16le",
+				sampleRate: 16e3,
+				channels: 1
+			},
+			...stt.apiKey ? { apiKey: stt.apiKey } : {},
+			...stt.baseUrl ? { baseUrl: stt.baseUrl } : {},
+			...stt.headers ? { headers: stt.headers } : {},
+			...stt.language ? { language: stt.language } : {},
+			...stt.prompt ? { prompt: stt.prompt } : {},
+			turnDetection: {
+				mode: consumed.inputMode,
+				silenceDurationMs: consumed.silenceDurationMs
+			},
+			timeoutMs: 15e3,
+			signal: AbortSignal.any([options.signal, sttAbort.signal]),
+			onEvent: (event) => {
+				if (generation === sttGeneration) onSttEvent(event);
+			}
+		});
+	}
+	function onSttEvent(event) {
+		if (closed) return;
+		if (event.type === "ready" || event.type === "usage") return;
+		if (event.type === "error") {
+			log.warn({
+				err: event.error,
+				sessionId: claim.sessionId,
+				provider: stt.route.provider
+			}, "Realtime STT failed");
+			send("session.error", {
+				code: "PROVIDER_ERROR",
+				message: "Streaming transcription failed",
+				recoverable: false
+			});
+			options.onClose("provider_error", true);
+			return;
+		}
+		if (muted || finalizedUtterances.has(event.utteranceId)) return;
+		if (event.type === "speech_started") {
+			if (claim.request.purpose === "conversation" && claim.config.voice?.realtime?.bargeIn && !activeResponse?.awaitingClarification) cancelActiveResponse("barge_in");
+			send("input.speech_started", { utteranceId: event.utteranceId });
+		}
+		if (event.type === "speech_stopped") send("input.speech_stopped", { utteranceId: event.utteranceId });
+		if (event.type === "transcript_delta") send("input.transcript.delta", {
+			utteranceId: event.utteranceId,
+			revision: event.revision,
+			text: event.text
+		});
+		if (event.type === "transcript_final") {
+			const text = event.text.trim();
+			if (!text) return;
+			if (finalizedUtterances.size >= 1e4) {
+				options.onClose("utterance_limit", true);
+				return;
+			}
+			finalizedUtterances.add(event.utteranceId);
+			finalCount += 1;
+			send("input.transcript.final", {
+				utteranceId: event.utteranceId,
+				revision: event.revision,
+				text,
+				...event.language === "zh" || event.language === "en" ? { language: event.language } : {}
+			});
+			if (claim.request.purpose === "conversation") {
+				if (activeResponse?.awaitingClarification) return;
+				if (claim.config.voice?.realtime?.bargeIn) cancelActiveResponse("barge_in");
+				if (queuedTurns >= 8) {
+					send("session.error", {
+						code: "INPUT_BACKPRESSURE",
+						message: "Too many queued voice turns",
+						recoverable: false
+					});
+					options.onClose("input_backpressure", true);
+					return;
+				}
+				queuedTurns += 1;
+				const generation = inputGeneration;
+				conversationTail = conversationTail.then(() => {
+					if (generation === inputGeneration) return runConversationTurn(text);
+				}).finally(() => {
+					if (generation === inputGeneration) queuedTurns -= 1;
+				});
+			}
+		}
+	}
+	function discardInput() {
+		inputGeneration += 1;
+		queuedTurns = 0;
+		bufferedAudio = [];
+		bufferedBytes = 0;
+		const generation = ++sttGeneration;
+		sttAbort.abort("input_discarded");
+		sttAbort = new AbortController();
+		sttSession?.abort("input_discarded");
+		sttSession = void 0;
+		inputReset = openSttSession(claim).then((opened) => {
+			if (closed || generation !== sttGeneration) {
+				opened.abort("input_replaced");
+				return;
+			}
+			sttSession = opened;
+			for (const bytes of bufferedAudio) opened.appendAudio(bytes);
+			bufferedAudio = [];
+			bufferedBytes = 0;
+		}).catch((error) => {
+			if (!closed && generation === sttGeneration) throw error;
+		});
+		return inputReset;
+	}
+	return {
+		async start() {
+			const opened = await openSttSession(claim);
+			if (closed || options.signal.aborted) {
+				opened.abort("session_closed");
+				throw new Error("Voice session closed during initialization");
+			}
+			sttSession = opened;
+		},
+		async setInputMuted(next) {
+			if (closed || muted === next) return;
+			muted = next;
+			if (!next) return inputReset;
+			return discardInput();
+		},
+		appendAudio(bytes) {
+			if (muted) return;
+			if (!closed && !sttSession && inputReset) {
+				if (bufferedBytes + bytes.byteLength > 64e3) throw new Error("Voice input reset exceeded audio buffer");
+				bufferedAudio.push(Uint8Array.from(bytes));
+				bufferedBytes += bytes.byteLength;
+				return;
+			}
+			if (closed || !sttSession || committing) throw new Error("Voice input is not ready");
+			sttSession.appendAudio(bytes);
+		},
+		async commit() {
+			if (claim.request.purpose !== "dictation" || committing || !sttSession || closed) throw new Error("Input cannot be committed");
+			committing = true;
+			await sttSession.commit();
+			if (closed) return;
+			if (finalCount === 0) send("session.error", {
+				code: "EMPTY_UTTERANCE",
+				message: "No speech was recognized",
+				recoverable: true
+			});
+			await options.onClose("input_committed", true);
+		},
+		cancel(responseId, reason) {
+			if (activeResponse?.id !== responseId) return false;
+			if (reason === "client_cancelled") discardInput().catch((error) => {
+				log.warn({
+					err: error,
+					sessionId: claim.sessionId
+				}, "Voice input reset after interruption failed");
+				send("session.error", {
+					code: "PROVIDER_ERROR",
+					message: "Could not resume microphone input",
+					recoverable: false
+				});
+				options.onClose("provider_error", true);
+			});
+			return cancelActiveResponse(reason);
+		},
+		acknowledge(responseId, playedBytes) {
+			if (activeResponse?.id === responseId) activeResponse.playback.acknowledge(playedBytes);
+		},
+		close() {
+			if (closing) return closing;
+			closed = true;
+			cancelActiveResponse("session_closed");
+			sttAbort.abort("session_closed");
+			sttSession?.abort("session_closed");
+			closing = Promise.all([
+				conversationTail,
+				interruptionWrites,
+				inputReset
+			]).then(() => {});
+			return closing;
+		}
+	};
+}
+//#endregion
+export { createAgentVoiceEngine };

package/dist/src/voice/realtime/audio-playback-window.d.ts

@@ -0,0 +1,9 @@
+export declare class AudioPlaybackWindow {
+    private sentBytes;
+    private playedBytes;
+    private wake?;
+    acknowledge(playedBytes: number): void;
+    reserve(bytes: number, signal: AbortSignal): Promise<void>;
+    drain(signal: AbortSignal): Promise<void>;
+    private wait;
+}

package/dist/src/voice/realtime/audio-playback-window.js

@@ -0,0 +1,49 @@
+//#region src/voice/realtime/audio-playback-window.ts
+const MAX_PENDING_BYTES = 96e3;
+const PLAYBACK_TIMEOUT_MS = 15e3;
+var AudioPlaybackWindow = class {
+	sentBytes = 0;
+	playedBytes = 0;
+	wake;
+	acknowledge(playedBytes) {
+		if (playedBytes > this.sentBytes) throw new Error("Playback acknowledgement exceeds sent audio");
+		if (playedBytes <= this.playedBytes) return;
+		this.playedBytes = playedBytes;
+		this.wake?.();
+	}
+	async reserve(bytes, signal) {
+		if (bytes > MAX_PENDING_BYTES) throw new Error("Audio frame exceeds playback window");
+		while (this.sentBytes - this.playedBytes + bytes > MAX_PENDING_BYTES) await this.wait(signal);
+		signal.throwIfAborted();
+		this.sentBytes += bytes;
+	}
+	async drain(signal) {
+		while (this.sentBytes > this.playedBytes) await this.wait(signal);
+		signal.throwIfAborted();
+	}
+	wait(signal) {
+		signal.throwIfAborted();
+		return new Promise((resolve, reject) => {
+			const cleanup = () => {
+				clearTimeout(timer);
+				signal.removeEventListener("abort", onAbort);
+				this.wake = void 0;
+			};
+			const onAbort = () => {
+				cleanup();
+				reject(signal.reason);
+			};
+			const timer = setTimeout(() => {
+				cleanup();
+				reject(/* @__PURE__ */ new Error("Voice playback acknowledgement timed out"));
+			}, PLAYBACK_TIMEOUT_MS);
+			this.wake = () => {
+				cleanup();
+				resolve();
+			};
+			signal.addEventListener("abort", onAbort, { once: true });
+		});
+	}
+};
+//#endregion
+export { AudioPlaybackWindow };

package/dist/src/voice/realtime/conversation-context.d.ts

@@ -0,0 +1,11 @@
+import type { AgentMessage } from '@earendil-works/pi-agent-core';
+import type { VoiceMemorySnapshot } from './memory-context.js';
+export interface VoiceConversationContext {
+    identity: string;
+    history: AgentMessage[];
+    memory?: VoiceMemorySnapshot;
+}
+/** Use the canonical, already-compacted Session context. No tools or hidden reasoning. */
+export declare function buildVoiceHistory(messages: AgentMessage[], budget?: number): string;
+export declare function voiceMemoryBudget(base: string, context: VoiceConversationContext): number;
+export declare function voiceConversationInstructions(base: string, context: VoiceConversationContext): string;