@agent-native/core 0.97.0 → 0.98.1

package/dist/client/composer/useRealtimeVoiceMode.js

@@ -11,9 +11,333 @@ import { createRealtimeVoiceAudioLevelStore, normalizeRealtimeVoiceRms, smoothRe
 import { realtimeVoiceTranscriptRegistry } from "./realtime-voice-transcript.js";
 import { RealtimeVoiceModeDock, } from "./RealtimeVoiceMode.js";
 const REALTIME_VOICE_STATE_KEY = "realtime-voice-session";
+const REALTIME_VOICE_PREFERENCES_KEY = "realtime-voice-prefs";
 const REALTIME_VOICE_REQUEST_SOURCE = "realtime-voice";
 const REALTIME_VOICE_SESSION_PATH = "/_agent-native/realtime-voice/session";
 const REALTIME_VOICE_TOOL_PATH = "/_agent-native/realtime-voice/tool";
+const REALTIME_VOICE_CAPABILITY_HEADER = "X-Agent-Native-Realtime-Capability";
+const REALTIME_VOICE_CONNECTION_TIMEOUT_MS = 15_000;
+const REALTIME_VOICE_MAX_TOOLS = 32;
+const REALTIME_VOICE_MAX_TOOL_SCHEMA_BYTES = 32_000;
+const REALTIME_VOICE_MAX_SESSION_BYTES = 64_000;
+const REALTIME_VOICE_TOOL_UPDATE_TIMEOUT_MS = 5_000;
+const REALTIME_VOICE_PRIORITY_TOOL_NAMES = [
+    "navigate",
+    "set-url-path",
+    "set-search-params",
+    "view-screen",
+    "tool-search",
+];
+const REALTIME_VOICE_TOOL_NAME = /^[A-Za-z0-9_-]{1,64}$/;
+const REALTIME_VOICE_MICROPHONE_STORAGE_KEY = "agent-native:realtime-voice-microphone";
+export const REALTIME_VOICE_LANGUAGES = [
+    "auto",
+    "en",
+    "es",
+    "fr",
+    "de",
+    "it",
+    "pt",
+    "ja",
+    "ko",
+    "zh",
+];
+export const REALTIME_VOICE_INTELLIGENCE_LEVELS = [
+    "instant",
+    "balanced",
+    "deep",
+];
+export const REALTIME_VOICES = [
+    "marin",
+    "cedar",
+    "coral",
+    "sage",
+    "verse",
+    "alloy",
+    "ash",
+    "ballad",
+    "echo",
+    "shimmer",
+];
+export const DEFAULT_REALTIME_VOICE_PREFERENCES = {
+    language: "auto",
+    intelligence: "instant",
+    voice: "marin",
+};
+export const REALTIME_VOICE_AUDIO_CONSTRAINTS = {
+    // Prefer the browser/OS-selected input instead of whichever physical device
+    // happens to be enumerated first. `ideal` keeps browsers without the
+    // synthetic `default` device from failing with OverconstrainedError.
+    deviceId: { ideal: "default" },
+    echoCancellation: true,
+    noiseSuppression: true,
+    autoGainControl: true,
+};
+export function createRealtimeVoiceAudioConstraints(deviceId = "default", exact = false) {
+    return {
+        ...REALTIME_VOICE_AUDIO_CONSTRAINTS,
+        deviceId: deviceId === "default"
+            ? { ideal: "default" }
+            : exact
+                ? { exact: deviceId }
+                : { ideal: deviceId },
+    };
+}
+export async function replaceRealtimeVoiceMicrophone(options) {
+    const replacementStream = await options.mediaDevices.getUserMedia({
+        audio: createRealtimeVoiceAudioConstraints(options.deviceId, true),
+    });
+    try {
+        const replacementTrack = replacementStream.getAudioTracks()[0];
+        const sender = options.peer
+            .getSenders()
+            .find((candidate) => candidate.track?.kind === "audio");
+        if (!replacementTrack || !sender) {
+            throw new Error("No active microphone track is available.");
+        }
+        await sender.replaceTrack(replacementTrack);
+        for (const track of options.currentStream?.getTracks() ?? []) {
+            track.onended = null;
+            track.stop();
+        }
+        return replacementStream;
+    }
+    catch (error) {
+        for (const track of replacementStream.getTracks())
+            track.stop();
+        throw error;
+    }
+}
+function readRealtimeVoiceMicrophoneId() {
+    if (typeof window === "undefined")
+        return "default";
+    try {
+        return (window.localStorage.getItem(REALTIME_VOICE_MICROPHONE_STORAGE_KEY) ||
+            "default");
+    }
+    catch {
+        return "default";
+    }
+}
+function writeRealtimeVoiceMicrophoneId(deviceId) {
+    try {
+        window.localStorage.setItem(REALTIME_VOICE_MICROPHONE_STORAGE_KEY, deviceId);
+    }
+    catch {
+        // A remembered local device is optional and must never block voice mode.
+    }
+}
+function isOneOf(values, value) {
+    return typeof value === "string" && values.includes(value);
+}
+export function normalizeRealtimeVoicePreferences(value) {
+    const record = value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+    return {
+        language: isOneOf(REALTIME_VOICE_LANGUAGES, record.language)
+            ? record.language
+            : DEFAULT_REALTIME_VOICE_PREFERENCES.language,
+        intelligence: isOneOf(REALTIME_VOICE_INTELLIGENCE_LEVELS, record.intelligence)
+            ? record.intelligence
+            : DEFAULT_REALTIME_VOICE_PREFERENCES.intelligence,
+        voice: isOneOf(REALTIME_VOICES, record.voice)
+            ? record.voice
+            : DEFAULT_REALTIME_VOICE_PREFERENCES.voice,
+    };
+}
+export function resolveRealtimeVoiceLanguage(language, browserLanguages = []) {
+    if (language !== "auto")
+        return language;
+    for (const locale of browserLanguages) {
+        const primary = locale.trim().split("-")[0]?.toLowerCase();
+        if (isOneOf(REALTIME_VOICE_LANGUAGES, primary) && primary !== "auto") {
+            return primary;
+        }
+    }
+    return "en";
+}
+export function realtimeVoiceReasoningEffort(intelligence) {
+    if (intelligence === "balanced")
+        return "low";
+    if (intelligence === "deep")
+        return "medium";
+    return "minimal";
+}
+export function createRealtimeVoicePreferenceUpdate(preferences, options = {}) {
+    return {
+        type: "session.update",
+        session: {
+            type: "realtime",
+            reasoning: {
+                effort: realtimeVoiceReasoningEffort(preferences.intelligence),
+            },
+            audio: {
+                input: {
+                    transcription: {
+                        model: "gpt-4o-mini-transcribe",
+                        language: resolveRealtimeVoiceLanguage(preferences.language, options.browserLanguages),
+                    },
+                },
+                ...(options.includeVoice
+                    ? { output: { voice: preferences.voice } }
+                    : {}),
+            },
+        },
+    };
+}
+/**
+ * Input transcription is produced by a separate ASR model and can finish after
+ * the assistant response. Reserve each message's position when OpenAI adds it
+ * to the conversation, then publish only the contiguous completed prefix.
+ */
+export function createRealtimeVoiceTranscriptSequencer(publish) {
+    const order = [];
+    const items = new Map();
+    const settledItemIds = new Set();
+    const receivedTranscriptIds = new Set();
+    const reserve = (id, role) => {
+        if (settledItemIds.has(id))
+            return;
+        const existing = items.get(id);
+        if (existing) {
+            existing.role ??= role;
+            return;
+        }
+        order.push(id);
+        items.set(id, { status: "pending", role });
+    };
+    const drain = () => {
+        while (order.length > 0) {
+            const id = order[0];
+            const entry = items.get(id);
+            if (!entry || entry.status === "pending")
+                return;
+            order.shift();
+            items.delete(id);
+            settledItemIds.add(id);
+            if (entry.status === "completed" && entry.transcript) {
+                publish(entry.transcript);
+            }
+        }
+    };
+    const skip = (id) => {
+        if (typeof id !== "string" || !id)
+            return;
+        reserve(id);
+        const entry = items.get(id);
+        if (entry.status === "pending")
+            entry.status = "skipped";
+    };
+    return {
+        handle(event) {
+            if (event.type === "conversation.item.added" ||
+                event.type === "conversation.item.created") {
+                const item = event.item;
+                if (item && typeof item === "object") {
+                    const record = item;
+                    if (record.type === "message" &&
+                        (record.role === "user" || record.role === "assistant") &&
+                        typeof record.id === "string") {
+                        reserve(record.id, record.role);
+                    }
+                }
+            }
+            const transcript = extractCompletedRealtimeVoiceTranscript(event);
+            if (transcript) {
+                const transcriptId = transcript.providerId
+                    ? `${transcript.role}:${transcript.providerId}`
+                    : undefined;
+                if (transcriptId && receivedTranscriptIds.has(transcriptId))
+                    return;
+                if (transcriptId)
+                    receivedTranscriptIds.add(transcriptId);
+                const itemId = typeof event.item_id === "string" ? event.item_id : undefined;
+                if (!itemId) {
+                    // Older providers may omit item_id. Match the first reserved slot for
+                    // that role so one incomplete legacy event cannot strand the queue.
+                    const reservedId = order.find((id) => {
+                        const entry = items.get(id);
+                        return (entry?.status === "pending" && entry.role === transcript.role);
+                    });
+                    if (reservedId) {
+                        items.set(reservedId, {
+                            status: "completed",
+                            role: transcript.role,
+                            transcript,
+                        });
+                    }
+                    else {
+                        publish(transcript);
+                    }
+                }
+                else {
+                    if (settledItemIds.has(itemId))
+                        return;
+                    reserve(itemId, transcript.role);
+                    items.set(itemId, {
+                        status: "completed",
+                        role: transcript.role,
+                        transcript,
+                    });
+                }
+            }
+            else if (event.type === "conversation.item.input_audio_transcription.failed" ||
+                event.type === "conversation.item.deleted") {
+                skip(event.item_id);
+            }
+            else if (event.type === "response.done") {
+                const response = event.response;
+                const output = response && typeof response === "object"
+                    ? response.output
+                    : undefined;
+                if (Array.isArray(output)) {
+                    for (const item of output) {
+                        if (!item || typeof item !== "object")
+                            continue;
+                        const record = item;
+                        if (record.type === "message")
+                            skip(record.id);
+                    }
+                }
+            }
+            drain();
+        },
+        reset() {
+            order.length = 0;
+            items.clear();
+            settledItemIds.clear();
+            receivedTranscriptIds.clear();
+        },
+    };
+}
+export function createRealtimeVoiceGreetingEvent() {
+    return {
+        type: "response.create",
+        response: {
+            output_modalities: ["audio"],
+            instructions: 'Say exactly: "How can I help you?" Do not add anything else.',
+            // Do not set max_output_tokens here. Realtime counts assistant audio at
+            // roughly one token per 50 ms, so a text-sized cap can cut speech off.
+            // The exact-response instruction already keeps this greeting bounded.
+        },
+    };
+}
+export function createRealtimeVoiceGreetingStarter(send) {
+    let started = false;
+    return {
+        start() {
+            if (started)
+                return false;
+            started = true;
+            send(createRealtimeVoiceGreetingEvent());
+            return true;
+        },
+        reset() {
+            started = false;
+        },
+    };
+}
 /**
  * Voice mode owns the chat only temporarily. Restore the captured transcript
  * when it is still the user's active thread (or the chat has no active thread)
@@ -41,6 +365,30 @@ export function extractCompletedRealtimeVoiceTranscript(event) {
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+export function isRealtimeVoiceAbortError(error) {
+    return Boolean(error &&
+        typeof error === "object" &&
+        error.name === "AbortError");
+}
+export function isRealtimeVoiceSetupRequiredError(error) {
+    return Boolean(error &&
+        typeof error === "object" &&
+        error.status === 409);
+}
+export function createRealtimeVoiceConnectionTimeout(onTimeout, timeoutMs = REALTIME_VOICE_CONNECTION_TIMEOUT_MS) {
+    const timeout = window.setTimeout(onTimeout, timeoutMs);
+    return () => window.clearTimeout(timeout);
+}
+export function createRealtimeVoiceConnectionGate(onTimeout, timeoutMs = REALTIME_VOICE_CONNECTION_TIMEOUT_MS) {
+    const cancel = createRealtimeVoiceConnectionTimeout(onTimeout, timeoutMs);
+    return {
+        // RTC connectivity alone is not enough: the session may never finish its
+        // Realtime handshake. Keep the deadline armed until session.created.
+        markTransportReady() { },
+        markSessionCreated: cancel,
+        cancel,
+    };
+}
 async function readErrorResponse(response) {
     const raw = await response.text().catch(() => "");
     if (!raw)
@@ -53,7 +401,8 @@ async function readErrorResponse(response) {
         return raw.slice(0, 500);
     }
 }
-export async function createRealtimeVoiceSession(offerSdp, options = {}) {
+export async function createRealtimeVoiceSessionWithCapability(offerSdp, options = {}) {
+    const preferences = options.preferences;
     const response = await fetch(agentNativePath(REALTIME_VOICE_SESSION_PATH), {
         method: "POST",
         credentials: "same-origin",
@@ -62,6 +411,13 @@ export async function createRealtimeVoiceSession(offerSdp, options = {}) {
             ...(options.browserTabId
                 ? { "X-Agent-Native-Browser-Tab": options.browserTabId }
                 : {}),
+            ...(preferences
+                ? {
+                    "X-Agent-Native-Realtime-Language": resolveRealtimeVoiceLanguage(preferences.language, options.browserLanguages),
+                    "X-Agent-Native-Realtime-Intelligence": preferences.intelligence,
+                    "X-Agent-Native-Realtime-Voice": preferences.voice,
+                }
+                : {}),
         },
         body: offerSdp,
         signal: options.signal,
@@ -72,7 +428,17 @@ export async function createRealtimeVoiceSession(offerSdp, options = {}) {
         error.status = response.status;
         throw error;
     }
-    return response.text();
+    const sdp = await response.text();
+    const capability = response.headers.get(REALTIME_VOICE_CAPABILITY_HEADER);
+    return {
+        sdp,
+        ...(capability ? { capability } : {}),
+    };
+}
+/** Backwards-compatible SDP-only session helper for existing client callers. */
+export async function createRealtimeVoiceSession(offerSdp, options = {}) {
+    return (await createRealtimeVoiceSessionWithCapability(offerSdp, options))
+        .sdp;
 }
 export async function executeRealtimeVoiceTool(input) {
     const response = await fetch(agentNativePath(REALTIME_VOICE_TOOL_PATH), {
@@ -83,6 +449,9 @@ export async function executeRealtimeVoiceTool(input) {
             ...(input.browserTabId
                 ? { "X-Agent-Native-Browser-Tab": input.browserTabId }
                 : {}),
+            ...(input.capability
+                ? { [REALTIME_VOICE_CAPABILITY_HEADER]: input.capability }
+                : {}),
         },
         body: JSON.stringify({
             name: input.name,
@@ -98,6 +467,217 @@ export async function executeRealtimeVoiceTool(input) {
     }
     return (await response.json());
 }
+function jsonByteLength(value) {
+    return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+}
+function normalizeRealtimeVoiceFunctionTool(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    if (record.type !== "function" ||
+        typeof record.name !== "string" ||
+        !REALTIME_VOICE_TOOL_NAME.test(record.name)) {
+        return null;
+    }
+    if (record.description !== undefined &&
+        typeof record.description !== "string") {
+        return null;
+    }
+    if (record.parameters !== undefined &&
+        (!record.parameters ||
+            typeof record.parameters !== "object" ||
+            Array.isArray(record.parameters))) {
+        return null;
+    }
+    try {
+        if (jsonByteLength(record) > REALTIME_VOICE_MAX_TOOL_SCHEMA_BYTES) {
+            return null;
+        }
+        return JSON.parse(JSON.stringify(record));
+    }
+    catch {
+        return null;
+    }
+}
+export function extractRealtimeVoiceSessionTools(event) {
+    if (event.type !== "session.created" && event.type !== "session.updated") {
+        return null;
+    }
+    const session = event.session;
+    if (!session || typeof session !== "object")
+        return null;
+    const tools = session.tools;
+    if (!Array.isArray(tools))
+        return null;
+    return tools
+        .map(normalizeRealtimeVoiceFunctionTool)
+        .filter((tool) => Boolean(tool));
+}
+function createRealtimeVoiceToolManifestUpdate(tools, eventId) {
+    return {
+        type: "session.update",
+        ...(eventId ? { event_id: eventId } : {}),
+        session: {
+            type: "realtime",
+            tools,
+            tool_choice: "auto",
+        },
+    };
+}
+/**
+ * Merge search-discovered schemas into the live manifest. Pinned navigation
+ * and discovery tools stay available, then the newest discoveries take the
+ * remaining slots ahead of lower-priority tools from the original manifest.
+ */
+export function mergeRealtimeVoiceToolManifest(currentTools, expandedTools) {
+    const current = new Map();
+    for (const value of currentTools) {
+        const tool = normalizeRealtimeVoiceFunctionTool(value);
+        if (tool)
+            current.set(tool.name, tool);
+    }
+    const expanded = new Map();
+    for (const value of expandedTools) {
+        const tool = normalizeRealtimeVoiceFunctionTool(value);
+        if (tool)
+            expanded.set(tool.name, tool);
+    }
+    const candidates = [];
+    const seen = new Set();
+    const add = (tool) => {
+        if (!tool || seen.has(tool.name))
+            return;
+        seen.add(tool.name);
+        candidates.push(tool);
+    };
+    for (const name of REALTIME_VOICE_PRIORITY_TOOL_NAMES) {
+        add(expanded.get(name) ?? current.get(name));
+    }
+    for (const tool of expanded.values())
+        add(tool);
+    for (const tool of current.values())
+        add(tool);
+    const packed = [];
+    for (const tool of candidates) {
+        if (packed.length >= REALTIME_VOICE_MAX_TOOLS)
+            break;
+        const candidate = [...packed, tool];
+        if (jsonByteLength(createRealtimeVoiceToolManifestUpdate(candidate, "realtime_tool_manifest_999999999")) <= REALTIME_VOICE_MAX_SESSION_BYTES) {
+            packed.push(tool);
+        }
+    }
+    return packed;
+}
+function createRealtimeVoiceToolResultEvent(result) {
+    const modelResult = {
+        callId: result.callId,
+        status: result.status,
+        output: result.output,
+        ...(result.approvalKey ? { approvalKey: result.approvalKey } : {}),
+    };
+    return {
+        type: "conversation.item.create",
+        item: {
+            type: "function_call_output",
+            call_id: result.callId,
+            output: JSON.stringify(modelResult),
+        },
+    };
+}
+/**
+ * Realtime treats `session.update.tools` as a full replacement. Serialize
+ * discovery updates and wait for a confirming `session.updated` manifest
+ * before returning the search result and allowing the next model response.
+ */
+export function createRealtimeVoiceToolManifestCoordinator(send, timeoutMs = REALTIME_VOICE_TOOL_UPDATE_TIMEOUT_MS) {
+    let currentTools = [];
+    const queue = [];
+    let updateSequence = 0;
+    let active;
+    const finish = (failureMessage) => {
+        if (!active)
+            return;
+        const { result, timer } = active;
+        clearTimeout(timer);
+        active = undefined;
+        send(createRealtimeVoiceToolResultEvent(failureMessage
+            ? {
+                callId: result.callId,
+                status: "failed",
+                output: `${failureMessage} The discovered tools were not added to this voice session. Original tool result: ${result.output}`,
+            }
+            : result));
+        send({ type: "response.create" });
+        drain();
+    };
+    const drain = () => {
+        if (active)
+            return;
+        const result = queue.shift();
+        if (!result)
+            return;
+        const expanded = Array.isArray(result.expandedTools)
+            ? result.expandedTools
+                .map(normalizeRealtimeVoiceFunctionTool)
+                .filter((tool) => Boolean(tool))
+            : [];
+        if (result.status !== "completed" || expanded.length === 0) {
+            send(createRealtimeVoiceToolResultEvent(result));
+            send({ type: "response.create" });
+            drain();
+            return;
+        }
+        const merged = mergeRealtimeVoiceToolManifest(currentTools, expanded);
+        const mergedNames = new Set(merged.map((tool) => tool.name));
+        const expectedNames = expanded
+            .map((tool) => tool.name)
+            .filter((name) => mergedNames.has(name));
+        if (expectedNames.length === 0) {
+            send(createRealtimeVoiceToolResultEvent(result));
+            send({ type: "response.create" });
+            drain();
+            return;
+        }
+        const eventId = `realtime_tool_manifest_${++updateSequence}`;
+        active = {
+            result,
+            expectedNames,
+            eventId,
+            timer: setTimeout(() => finish("Timed out while installing the discovered tools."), timeoutMs),
+        };
+        send(createRealtimeVoiceToolManifestUpdate(merged, eventId));
+    };
+    return {
+        enqueue(result) {
+            queue.push(result);
+            drain();
+        },
+        setSessionTools(tools) {
+            currentTools = mergeRealtimeVoiceToolManifest([], tools);
+            if (!active)
+                return;
+            const names = new Set(currentTools.map((tool) => tool.name));
+            if (active.expectedNames.every((name) => names.has(name)))
+                finish();
+        },
+        handleError(eventId, message) {
+            if (!active || !eventId || active.eventId !== eventId)
+                return false;
+            finish(message || "The provider rejected the discovered tool update.");
+            return true;
+        },
+        reset() {
+            if (active)
+                clearTimeout(active.timer);
+            active = undefined;
+            queue.length = 0;
+            currentTools = [];
+        },
+        getTools() {
+            return currentTools;
+        },
+    };
+}
 export function extractRealtimeVoiceFunctionCalls(event) {
     if (event.type === "response.function_call_arguments.done") {
         const name = typeof event.name === "string" ? event.name : "";
@@ -160,6 +740,10 @@ function openOpenAiKeySettings() {
         detail: { section: "secrets" },
     }));
 }
+export function listenForRealtimeVoicePageHide(cleanup) {
+    window.addEventListener("pagehide", cleanup);
+    return () => window.removeEventListener("pagehide", cleanup);
+}
 function voiceCopy(t) {
     return {
         entryButtonLabel: t("agentPanel.voiceMode.entryButtonLabel"),
@@ -175,6 +759,45 @@ function voiceCopy(t) {
         showChat: t("agentPanel.voiceMode.showChat"),
         hideChat: t("agentPanel.voiceMode.hideChat"),
         endVoiceMode: t("agentPanel.voiceMode.end"),
+        voiceSettings: t("agentPanel.voiceMode.voiceSettings"),
+        settings: {
+            language: t("agentPanel.voiceMode.settings.language"),
+            autoLanguage: t("agentPanel.voiceMode.settings.autoLanguage"),
+            languages: {
+                en: t("agentPanel.voiceMode.settings.languages.en"),
+                es: t("agentPanel.voiceMode.settings.languages.es"),
+                fr: t("agentPanel.voiceMode.settings.languages.fr"),
+                de: t("agentPanel.voiceMode.settings.languages.de"),
+                it: t("agentPanel.voiceMode.settings.languages.it"),
+                pt: t("agentPanel.voiceMode.settings.languages.pt"),
+                ja: t("agentPanel.voiceMode.settings.languages.ja"),
+                ko: t("agentPanel.voiceMode.settings.languages.ko"),
+                zh: t("agentPanel.voiceMode.settings.languages.zh"),
+            },
+            intelligence: t("agentPanel.voiceMode.settings.intelligence"),
+            intelligenceLevels: {
+                instant: t("agentPanel.voiceMode.settings.intelligenceLevels.instant"),
+                balanced: t("agentPanel.voiceMode.settings.intelligenceLevels.balanced"),
+                deep: t("agentPanel.voiceMode.settings.intelligenceLevels.deep"),
+            },
+            voiceStyle: t("agentPanel.voiceMode.settings.voiceStyle"),
+            microphone: t("agentPanel.voiceMode.settings.microphone"),
+            defaultMicrophone: t("agentPanel.voiceMode.settings.defaultMicrophone"),
+            microphoneSwitchFailed: t("agentPanel.voiceMode.settings.microphoneSwitchFailed"),
+            voiceChangePending: t("agentPanel.voiceMode.settings.voiceChangePending"),
+            voiceDescriptions: {
+                marin: t("agentPanel.voiceMode.settings.voiceDescriptions.marin"),
+                cedar: t("agentPanel.voiceMode.settings.voiceDescriptions.cedar"),
+                coral: t("agentPanel.voiceMode.settings.voiceDescriptions.coral"),
+                sage: t("agentPanel.voiceMode.settings.voiceDescriptions.sage"),
+                verse: t("agentPanel.voiceMode.settings.voiceDescriptions.verse"),
+                alloy: t("agentPanel.voiceMode.settings.voiceDescriptions.alloy"),
+                ash: t("agentPanel.voiceMode.settings.voiceDescriptions.ash"),
+                ballad: t("agentPanel.voiceMode.settings.voiceDescriptions.ballad"),
+                echo: t("agentPanel.voiceMode.settings.voiceDescriptions.echo"),
+                shimmer: t("agentPanel.voiceMode.settings.voiceDescriptions.shimmer"),
+            },
+        },
         status: {
             connecting: t("agentPanel.voiceMode.status.connecting"),
             listening: t("agentPanel.voiceMode.status.listening"),
@@ -188,6 +811,7 @@ function voiceCopy(t) {
             responseFailed: t("agentPanel.voiceMode.errors.responseFailed"),
             sessionFailed: t("agentPanel.voiceMode.errors.sessionFailed"),
             channelDisconnected: t("agentPanel.voiceMode.errors.channelDisconnected"),
+            connectionTimedOut: t("agentPanel.voiceMode.errors.connectionTimedOut"),
             connectionFailed: t("agentPanel.voiceMode.errors.connectionFailed"),
             offerFailed: t("agentPanel.voiceMode.errors.offerFailed"),
         },
@@ -201,8 +825,16 @@ function useRealtimeVoiceModeController(browserTabId, copy) {
     const [state, setState] = useState("idle");
     const [error, setError] = useState(null);
     const [chatVisible, setChatVisible] = useState(false);
+    const [preferences, setPreferences] = useState(DEFAULT_REALTIME_VOICE_PREFERENCES);
+    const [voiceChangePending, setVoiceChangePending] = useState(false);
+    const [microphones, setMicrophones] = useState([]);
+    const [microphoneDeviceId, setMicrophoneDeviceId] = useState(readRealtimeVoiceMicrophoneId);
+    const [microphoneSwitching, setMicrophoneSwitching] = useState(false);
+    const [microphoneError, setMicrophoneError] = useState(null);
     const [audioLevels] = useState(createRealtimeVoiceAudioLevelStore);
     const stateRef = useRef(state);
+    const preferencesRef = useRef(preferences);
+    const hasOutputAudioRef = useRef(false);
     const peerRef = useRef(null);
     const channelRef = useRef(null);
     const streamRef = useRef(null);
@@ -217,16 +849,47 @@ function useRealtimeVoiceModeController(browserTabId, copy) {
     const meterFrameRef = useRef(null);
     const lastMeterSampleRef = useRef(0);
     const abortRef = useRef(null);
+    const connectionGateRef = useRef(null);
     const handledCallsRef = useRef(new Set());
     const sessionIdRef = useRef(undefined);
+    const capabilityRef = useRef(undefined);
+    const transportGenerationRef = useRef(0);
     const startedAtRef = useRef(undefined);
     const lastUserTextRef = useRef("");
     const lastAssistantTextRef = useRef("");
     const transcriptThreadIdRef = useRef(undefined);
     const transcriptSequenceRef = useRef(0);
+    const preferencesHydratedRef = useRef(false);
+    const preferencesEditedRef = useRef(false);
+    const preferenceWriteChainRef = useRef(Promise.resolve());
+    const toolManifestCoordinator = useMemo(() => createRealtimeVoiceToolManifestCoordinator((event) => {
+        sendDataChannelEvent(channelRef.current, event);
+    }), []);
+    const switchMicrophoneRef = useRef(async () => undefined);
     useEffect(() => {
         stateRef.current = state;
     }, [state]);
+    useEffect(() => {
+        preferencesRef.current = preferences;
+    }, [preferences]);
+    const hydratePreferences = useCallback(async () => {
+        if (preferencesHydratedRef.current)
+            return;
+        try {
+            const stored = await readClientAppState(REALTIME_VOICE_PREFERENCES_KEY);
+            if (!preferencesEditedRef.current && stored != null) {
+                const next = normalizeRealtimeVoicePreferences(stored);
+                preferencesRef.current = next;
+                setPreferences(next);
+            }
+        }
+        catch {
+            // Preferences are optional; keep safe defaults when storage is unavailable.
+        }
+        finally {
+            preferencesHydratedRef.current = true;
+        }
+    }, []);
     const syncAppState = useCallback((nextState) => {
         const value = nextState === "idle"
             ? null
@@ -237,6 +900,7 @@ function useRealtimeVoiceModeController(browserTabId, copy) {
                 startedAt: startedAtRef.current,
                 sessionId: sessionIdRef.current,
                 browserTabId,
+                preferences: preferencesRef.current,
                 lastUserText: lastUserTextRef.current || undefined,
                 lastAssistantText: lastAssistantTextRef.current || undefined,
             };
@@ -249,6 +913,70 @@ function useRealtimeVoiceModeController(browserTabId, copy) {
         setState(nextState);
         syncAppState(nextState);
     }, [syncAppState]);
+    const savePreferences = useCallback((next) => {
+        preferencesEditedRef.current = true;
+        preferencesHydratedRef.current = true;
+        preferencesRef.current = next;
+        setPreferences(next);
+        preferenceWriteChainRef.current = preferenceWriteChainRef.current
+            .catch(() => undefined)
+            .then(async () => {
+            await setClientAppState(REALTIME_VOICE_PREFERENCES_KEY, next, {
+                requestSource: REALTIME_VOICE_REQUEST_SOURCE,
+            });
+        })
+            .catch(() => undefined);
+    }, []);
+    const updateLivePreferences = useCallback((next, includeVoice = false) => {
+        sendDataChannelEvent(channelRef.current, createRealtimeVoicePreferenceUpdate(next, {
+            browserLanguages: typeof navigator === "undefined" ? [] : navigator.languages,
+            includeVoice,
+        }));
+    }, []);
+    const setLanguage = useCallback((language) => {
+        const next = { ...preferencesRef.current, language };
+        savePreferences(next);
+        updateLivePreferences(next);
+    }, [savePreferences, updateLivePreferences]);
+    const setIntelligence = useCallback((intelligence) => {
+        const next = { ...preferencesRef.current, intelligence };
+        savePreferences(next);
+        updateLivePreferences(next);
+    }, [savePreferences, updateLivePreferences]);
+    const setVoice = useCallback((voice) => {
+        const next = { ...preferencesRef.current, voice };
+        savePreferences(next);
+        if (hasOutputAudioRef.current) {
+            setVoiceChangePending(true);
+            updateLivePreferences(next);
+            return;
+        }
+        setVoiceChangePending(false);
+        updateLivePreferences(next, true);
+    }, [savePreferences, updateLivePreferences]);
+    const refreshMicrophones = useCallback(async () => {
+        const mediaDevices = navigator.mediaDevices;
+        if (!mediaDevices?.enumerateDevices)
+            return null;
+        try {
+            const devices = await mediaDevices.enumerateDevices();
+            const inputs = devices
+                .filter((device) => device.kind === "audioinput" &&
+                device.deviceId &&
+                device.deviceId !== "default" &&
+                device.deviceId !== "communications")
+                .map((device, index) => ({
+                deviceId: device.deviceId,
+                label: device.label || `Microphone ${index + 1}`,
+            }));
+            setMicrophones(inputs);
+            return inputs;
+        }
+        catch {
+            // Enumeration is progressive enhancement; system default remains usable.
+            return null;
+        }
+    }, []);
     const startMeterLoop = useCallback(() => {
         if (meterFrameRef.current !== null)
             return;
@@ -308,15 +1036,65 @@ function useRealtimeVoiceModeController(browserTabId, copy) {
             // Audio metering is visual-only; keep the realtime call healthy.
         }
     }, [startMeterLoop]);
+    const setMicrophone = useCallback(async (deviceId, force = false) => {
+        if ((!force && deviceId === microphoneDeviceId) || microphoneSwitching) {
+            return;
+        }
+        const mediaDevices = navigator.mediaDevices;
+        const peer = peerRef.current;
+        if (!mediaDevices?.getUserMedia || !peer)
+            return;
+        setMicrophoneSwitching(true);
+        setMicrophoneError(null);
+        try {
+            const replacementStream = await replaceRealtimeVoiceMicrophone({
+                mediaDevices,
+                peer,
+                currentStream: streamRef.current,
+                deviceId,
+            });
+            const replacementTrack = replacementStream.getAudioTracks()[0];
+            streamRef.current = replacementStream;
+            if (replacementTrack) {
+                replacementTrack.onended = () => {
+                    void switchMicrophoneRef.current("default", true);
+                };
+            }
+            attachAudioMeter(streamRef.current, "input");
+            writeRealtimeVoiceMicrophoneId(deviceId);
+            setMicrophoneDeviceId(deviceId);
+            await refreshMicrophones();
+        }
+        catch {
+            setMicrophoneError(copy?.settings.microphoneSwitchFailed ??
+                "Could not switch microphones. Your current microphone is still active.");
+        }
+        finally {
+            setMicrophoneSwitching(false);
+        }
+    }, [
+        attachAudioMeter,
+        copy,
+        microphoneDeviceId,
+        microphoneSwitching,
+        refreshMicrophones,
+    ]);
+    switchMicrophoneRef.current = setMicrophone;
     const cleanupTransport = useCallback(() => {
+        connectionGateRef.current?.cancel();
+        connectionGateRef.current = null;
+        transportGenerationRef.current += 1;
+        capabilityRef.current = undefined;
         abortRef.current?.abort();
         abortRef.current = null;
         channelRef.current?.close();
         channelRef.current = null;
         peerRef.current?.close();
         peerRef.current = null;
-        for (const track of streamRef.current?.getTracks() ?? [])
+        for (const track of streamRef.current?.getTracks() ?? []) {
+            track.onended = null;
             track.stop();
+        }
         streamRef.current = null;
         if (audioRef.current) {
             audioRef.current.pause();
@@ -342,7 +1120,8 @@ function useRealtimeVoiceModeController(browserTabId, copy) {
             void audioContext.close().catch(() => undefined);
         audioLevels.reset();
         handledCallsRef.current.clear();
-    }, [audioLevels]);
+        toolManifestCoordinator.reset();
+    }, [audioLevels, toolManifestCoordinator]);
     const fail = useCallback((message, options) => {
         cleanupTransport();
         setError(message);
@@ -354,6 +1133,8 @@ function useRealtimeVoiceModeController(browserTabId, copy) {
         if (handledCallsRef.current.has(call.callId))
             return;
         handledCallsRef.current.add(call.callId);
+        const transportGeneration = transportGenerationRef.current;
+        const transportChannel = channelRef.current;
         transition("working");
         let result;
         try {
@@ -364,6 +1145,7 @@ function useRealtimeVoiceModeController(browserTabId, copy) {
                 callId: call.callId,
                 sessionId: sessionIdRef.current,
                 browserTabId,
+                capability: capabilityRef.current,
                 signal: abortRef.current?.signal,
             });
         }
@@ -374,20 +1156,15 @@ function useRealtimeVoiceModeController(browserTabId, copy) {
                 output: errorMessage(toolError),
             };
         }
-        sendDataChannelEvent(channelRef.current, {
-            type: "conversation.item.create",
-            item: {
-                type: "function_call_output",
-                call_id: call.callId,
-                output: JSON.stringify(result),
-            },
-        });
-        sendDataChannelEvent(channelRef.current, { type: "response.create" });
-    }, [browserTabId, transition]);
-    const persistCompletedTranscript = useCallback((event) => {
-        const transcript = extractCompletedRealtimeVoiceTranscript(event);
+        if (transportGeneration !== transportGenerationRef.current ||
+            channelRef.current !== transportChannel) {
+            return;
+        }
+        toolManifestCoordinator.enqueue(result);
+    }, [browserTabId, toolManifestCoordinator, transition]);
+    const publishCompletedTranscript = useCallback((transcript) => {
         const threadId = transcriptThreadIdRef.current;
-        if (!transcript || !threadId)
+        if (!threadId)
             return;
         const sessionIdentity = sessionIdRef.current ?? startedAtRef.current ?? "pending";
         const providerIdentity = transcript.providerId ?? `sequence-${++transcriptSequenceRef.current}`;
@@ -399,15 +1176,27 @@ function useRealtimeVoiceModeController(browserTabId, copy) {
             createdAt: new Date().toISOString(),
         });
     }, []);
+    const transcriptSequencer = useMemo(() => createRealtimeVoiceTranscriptSequencer(publishCompletedTranscript), [publishCompletedTranscript]);
+    const greetingStarter = useMemo(() => createRealtimeVoiceGreetingStarter((event) => {
+        sendDataChannelEvent(channelRef.current, event);
+    }), []);
     const handleServerEvent = useCallback((event) => {
+        transcriptSequencer.handle(event);
+        const sessionTools = extractRealtimeVoiceSessionTools(event);
+        if (sessionTools)
+            toolManifestCoordinator.setSessionTools(sessionTools);
         if (event.type === "session.created") {
+            connectionGateRef.current?.markSessionCreated();
+            connectionGateRef.current = null;
             const session = event.session;
             if (session && typeof session === "object") {
                 const id = session.id;
                 if (typeof id === "string")
                     sessionIdRef.current = id;
             }
-            transition("listening");
+            updateLivePreferences(preferencesRef.current, true);
+            greetingStarter.start();
+            transition("working");
         }
         else if (event.type === "input_audio_buffer.speech_started") {
             transition("listening");
@@ -416,10 +1205,14 @@ function useRealtimeVoiceModeController(browserTabId, copy) {
             transition("working");
         }
         else if (event.type === "response.created") {
+            // From this point onward the response is committed to audio output, so
+            // changing voices risks violating Realtime's per-session voice lock.
+            hasOutputAudioRef.current = true;
             lastAssistantTextRef.current = "";
             transition("working");
         }
         else if (event.type === "response.output_audio_transcript.delta") {
+            hasOutputAudioRef.current = true;
             if (typeof event.delta === "string") {
                 lastAssistantTextRef.current += event.delta;
             }
@@ -429,14 +1222,12 @@ function useRealtimeVoiceModeController(browserTabId, copy) {
             if (typeof event.transcript === "string") {
                 lastAssistantTextRef.current = event.transcript;
             }
-            persistCompletedTranscript(event);
             syncAppState("speaking");
         }
         else if (event.type === "conversation.item.input_audio_transcription.completed") {
             if (typeof event.transcript === "string") {
                 lastUserTextRef.current = event.transcript;
             }
-            persistCompletedTranscript(event);
             syncAppState("working");
         }
         else if (event.type === "response.done") {
@@ -457,6 +1248,12 @@ function useRealtimeVoiceModeController(browserTabId, copy) {
                 : typeof detail === "string"
                     ? detail
                     : "";
+            const expansionEventId = detail && typeof detail === "object"
+                ? (detail.event_id ?? event.event_id)
+                : event.event_id;
+            if (toolManifestCoordinator.handleError(typeof expansionEventId === "string" ? expansionEventId : undefined, message)) {
+                return;
+            }
             fail(message ||
                 copy?.errors.sessionFailed ||
                 "The realtime voice session encountered an error.");
@@ -471,10 +1268,13 @@ function useRealtimeVoiceModeController(browserTabId, copy) {
     }, [
         copy,
         fail,
+        greetingStarter,
         handleFunctionCall,
-        persistCompletedTranscript,
         syncAppState,
+        transcriptSequencer,
         transition,
+        toolManifestCoordinator,
+        updateLivePreferences,
     ]);
     const start = useCallback(async () => {
         if (stateRef.current !== "idle")
@@ -490,24 +1290,56 @@ function useRealtimeVoiceModeController(browserTabId, copy) {
         lastUserTextRef.current = "";
         lastAssistantTextRef.current = "";
         sessionIdRef.current = undefined;
+        hasOutputAudioRef.current = false;
+        greetingStarter.reset();
+        setVoiceChangePending(false);
         transcriptThreadIdRef.current =
             realtimeVoiceTranscriptRegistry.activeThreadId();
         transcriptSequenceRef.current = 0;
+        transcriptSequencer.reset();
         transition("connecting");
         setChatVisible(false);
         window.dispatchEvent(new Event("agent-panel:close"));
+        await hydratePreferences();
+        if (stateRef.current !== "connecting")
+            return;
         const abortController = new AbortController();
         abortRef.current = abortController;
+        const isCurrentAttempt = () => abortRef.current === abortController && !abortController.signal.aborted;
+        const connectionGate = createRealtimeVoiceConnectionGate(() => {
+            if (!isCurrentAttempt())
+                return;
+            fail(copy?.errors.connectionTimedOut ??
+                "The realtime voice connection timed out.");
+        });
+        connectionGateRef.current = connectionGate;
         try {
             const stream = await navigator.mediaDevices.getUserMedia({
-                audio: {
-                    echoCancellation: true,
-                    noiseSuppression: true,
-                    autoGainControl: true,
-                },
+                audio: createRealtimeVoiceAudioConstraints(readRealtimeVoiceMicrophoneId()),
             });
+            if (!isCurrentAttempt()) {
+                for (const track of stream.getTracks())
+                    track.stop();
+                return;
+            }
             streamRef.current = stream;
+            for (const track of stream.getAudioTracks()) {
+                track.onended = () => {
+                    void switchMicrophoneRef.current("default", true);
+                };
+            }
             attachAudioMeter(stream, "input");
+            void refreshMicrophones().then((inputs) => {
+                const selected = readRealtimeVoiceMicrophoneId();
+                if (inputs &&
+                    selected !== "default" &&
+                    !inputs.some((device) => device.deviceId === selected)) {
+                    // The persisted device was only an ideal preference, so getUserMedia
+                    // already selected a usable fallback for this new session.
+                    writeRealtimeVoiceMicrophoneId("default");
+                    setMicrophoneDeviceId("default");
+                }
+            });
             const peer = new RTCPeerConnection();
             peerRef.current = peer;
             for (const track of stream.getAudioTracks())
@@ -525,8 +1357,10 @@ function useRealtimeVoiceModeController(browserTabId, copy) {
             };
             const channel = peer.createDataChannel("oai-events");
             channelRef.current = channel;
-            channel.onopen = () => transition("listening");
+            channel.onopen = connectionGate.markTransportReady;
             channel.onmessage = (messageEvent) => {
+                if (!isCurrentAttempt())
+                    return;
                 try {
                     handleServerEvent(JSON.parse(String(messageEvent.data)));
                 }
@@ -534,38 +1368,83 @@ function useRealtimeVoiceModeController(browserTabId, copy) {
                     // Ignore malformed provider events without ending a healthy call.
                 }
             };
-            channel.onerror = () => fail(copy?.errors.channelDisconnected ??
-                "The realtime voice control channel disconnected.");
+            channel.onerror = () => {
+                if (!isCurrentAttempt())
+                    return;
+                fail(copy?.errors.channelDisconnected ??
+                    "The realtime voice control channel disconnected.");
+            };
             peer.onconnectionstatechange = () => {
-                if (peer.connectionState === "connected")
-                    transition("listening");
+                if (!isCurrentAttempt())
+                    return;
+                if (peer.connectionState === "connected") {
+                    connectionGate.markTransportReady();
+                }
                 if (peer.connectionState === "failed") {
                     fail(copy?.errors.connectionFailed ??
                         "The realtime voice connection failed.");
                 }
             };
             const offer = await peer.createOffer();
+            if (!isCurrentAttempt())
+                return;
             await peer.setLocalDescription(offer);
+            if (!isCurrentAttempt())
+                return;
             if (!offer.sdp) {
                 throw new Error(copy?.errors.offerFailed ??
                     "The browser did not create an audio offer.");
             }
-            const answerSdp = await createRealtimeVoiceSession(offer.sdp, {
+            const answer = await createRealtimeVoiceSessionWithCapability(offer.sdp, {
                 browserTabId,
                 signal: abortController.signal,
+                preferences: preferencesRef.current,
+                browserLanguages: navigator.languages,
             });
-            await peer.setRemoteDescription({ type: "answer", sdp: answerSdp });
+            if (!isCurrentAttempt())
+                return;
+            capabilityRef.current = answer.capability;
+            await peer.setRemoteDescription({ type: "answer", sdp: answer.sdp });
         }
         catch (startError) {
+            // Ending a connection aborts the SDP request by design. A superseded
+            // attempt must never resurrect the dock or surface that cancellation as
+            // an error after cleanup.
+            if (isRealtimeVoiceAbortError(startError) ||
+                abortController.signal.aborted ||
+                abortRef.current !== abortController) {
+                return;
+            }
+            if (isRealtimeVoiceSetupRequiredError(startError)) {
+                // Credentials can disappear after the entry-point status check. Treat
+                // the authoritative setup response as a gate, not as an active voice
+                // session failure: clean up the mic/RTC attempt, reopen chat, and
+                // refresh both the chat and voice provider setup surfaces.
+                cleanupTransport();
+                setError(null);
+                startedAtRef.current = undefined;
+                sessionIdRef.current = undefined;
+                transcriptThreadIdRef.current = undefined;
+                transition("idle");
+                setChatVisible(true);
+                window.dispatchEvent(new Event("agent-panel:open"));
+                window.dispatchEvent(new Event("agent-engine:configured-changed"));
+                return;
+            }
             const status = startError?.status;
             fail(errorMessage(startError), { openKeySettings: status === 400 });
         }
     }, [
         attachAudioMeter,
         browserTabId,
+        cleanupTransport,
         copy,
         fail,
+        greetingStarter,
         handleServerEvent,
+        hydratePreferences,
+        refreshMicrophones,
+        transcriptSequencer,
         transition,
     ]);
     const end = useCallback(() => {
@@ -598,6 +1477,23 @@ function useRealtimeVoiceModeController(browserTabId, copy) {
         setChatVisible((current) => !current);
         window.dispatchEvent(new Event("agent-panel:toggle"));
     }, []);
+    useEffect(() => {
+        const mediaDevices = navigator.mediaDevices;
+        if (!mediaDevices?.addEventListener)
+            return;
+        const handleDeviceChange = () => {
+            const selected = readRealtimeVoiceMicrophoneId();
+            void refreshMicrophones().then((inputs) => {
+                if (inputs &&
+                    selected !== "default" &&
+                    !inputs.some((device) => device.deviceId === selected)) {
+                    void setMicrophone("default");
+                }
+            });
+        };
+        mediaDevices.addEventListener("devicechange", handleDeviceChange);
+        return () => mediaDevices.removeEventListener("devicechange", handleDeviceChange);
+    }, [refreshMicrophones, setMicrophone]);
     useEffect(() => {
         const onSidebarState = (event) => {
             const detail = event
@@ -609,13 +1505,29 @@ function useRealtimeVoiceModeController(browserTabId, copy) {
         window.addEventListener(SIDEBAR_STATE_CHANGE_EVENT, onSidebarState);
         return () => window.removeEventListener(SIDEBAR_STATE_CHANGE_EVENT, onSidebarState);
     }, []);
-    useEffect(() => cleanupTransport, [cleanupTransport]);
+    useEffect(() => {
+        const stopListening = listenForRealtimeVoicePageHide(cleanupTransport);
+        return () => {
+            stopListening();
+            cleanupTransport();
+        };
+    }, [cleanupTransport]);
     return {
         state,
         active: state !== "idle",
         errorMessage: error,
         chatVisible,
         audioLevels,
+        preferences,
+        microphones,
+        microphoneDeviceId,
+        microphoneSwitching,
+        microphoneError,
+        voiceChangePending,
+        setLanguage,
+        setIntelligence,
+        setVoice,
+        setMicrophone,
         start,
         end,
         toggleChat,
@@ -626,8 +1538,76 @@ export function RealtimeVoiceModeProvider({ children, browserTabId, }) {
     const resolvedBrowserTabId = useMemo(() => browserTabId ?? getBrowserTabId(), [browserTabId]);
     const copy = useRealtimeVoiceModeCopy();
     const voice = useRealtimeVoiceModeController(resolvedBrowserTabId, copy);
+    const inlineSettings = useMemo(() => ({
+        dialogLabel: copy.voiceSettings,
+        ...(voice.voiceChangePending
+            ? { appliesNextConversationNote: copy.settings.voiceChangePending }
+            : {}),
+        ...(voice.microphoneError
+            ? { microphoneError: voice.microphoneError }
+            : {}),
+        microphone: {
+            label: copy.settings.microphone,
+            value: voice.microphoneDeviceId,
+            disabled: voice.microphoneSwitching,
+            options: [
+                {
+                    value: "default",
+                    label: copy.settings.defaultMicrophone,
+                },
+                ...voice.microphones.map((microphone) => ({
+                    value: microphone.deviceId,
+                    label: microphone.label,
+                })),
+            ],
+            onValueChange: (value) => {
+                void voice.setMicrophone(value);
+            },
+        },
+        language: {
+            label: copy.settings.language,
+            value: voice.preferences.language,
+            options: REALTIME_VOICE_LANGUAGES.map((language) => ({
+                value: language,
+                label: language === "auto"
+                    ? copy.settings.autoLanguage
+                    : copy.settings.languages[language],
+            })),
+            onValueChange: (value) => {
+                if (isOneOf(REALTIME_VOICE_LANGUAGES, value)) {
+                    voice.setLanguage(value);
+                }
+            },
+        },
+        intelligence: {
+            label: copy.settings.intelligence,
+            value: voice.preferences.intelligence,
+            options: REALTIME_VOICE_INTELLIGENCE_LEVELS.map((intelligence) => ({
+                value: intelligence,
+                label: copy.settings.intelligenceLevels[intelligence],
+            })),
+            onValueChange: (value) => {
+                if (isOneOf(REALTIME_VOICE_INTELLIGENCE_LEVELS, value)) {
+                    voice.setIntelligence(value);
+                }
+            },
+        },
+        voiceStyle: {
+            label: copy.settings.voiceStyle,
+            value: voice.preferences.voice,
+            options: REALTIME_VOICES.map((voiceName) => ({
+                value: voiceName,
+                label: `${voiceName[0].toUpperCase()}${voiceName.slice(1)}`,
+                description: copy.settings.voiceDescriptions[voiceName],
+            })),
+            onValueChange: (value) => {
+                if (isOneOf(REALTIME_VOICES, value))
+                    voice.setVoice(value);
+            },
+        },
+    }), [copy, voice]);
     return (_jsxs(RealtimeVoiceModeContext.Provider, { value: voice, children: [children, voice.active && typeof document !== "undefined"
-                ? createPortal(_jsx(RealtimeVoiceModeDock, { state: voice.state === "idle" ? "ending" : voice.state, copy: copy, chatVisible: voice.chatVisible, audioLevels: voice.audioLevels, onToggleChat: voice.toggleChat, onEndVoiceMode: voice.end, errorMessage: voice.errorMessage }), document.body)
+                ? createPortal(_jsx(RealtimeVoiceModeDock, { state: voice.state === "idle" ? "ending" : voice.state, copy: copy, chatVisible: voice.chatVisible, audioLevels: voice.audioLevels, onToggleChat: voice.toggleChat, onEndVoiceMode: voice.end, settings: inlineSettings, errorMessage: voice.errorMessage }), document.body)
                 : null] }));
 }
 /**