| import {languagePattern} from "../../shared/language.mjs"; |
| import { validateVoiceContext, voicePages } from "../../shared/voice-review.mjs"; |
| import { createSpeechEndpoint } from "../../shared/speech-endpoint.mjs"; |
| import { uiText } from "../../shared/ui-text.mjs"; |
| const $ = (id) => document.getElementById(id); |
| const blobData = (blob) => new Promise((resolve, reject) => { |
| const reader = new FileReader(); |
| reader.onload = () => resolve(reader.result); |
| reader.onerror = reject; |
| reader.readAsDataURL(blob); |
| }); |
| function createStudio({ api, getContext, requestJob, handleText = async () => null, canInterrupt = () => false, onVoiceCapture = () => { |
| }, onVoiceFinish = () => { |
| }, onReference, onReadout, onLibrary = () => { |
| }, notify, getScripted = () => null, scriptedMode = false, voiceOnly = false, mediaDevices = globalThis.navigator?.mediaDevices }) { |
| const conversationId = sessionStorage.getItem("vrbuild-conversation") || crypto.randomUUID(); |
| sessionStorage.setItem("vrbuild-conversation", conversationId); |
| let config = null, recorder = null, stream = null, recordTimer = null, recordState = "idle", stopRequested = false, audioPlayer = null, voiceGeneration = 0; |
| let pendingVoice = null, reviewPage = 0; |
| let messages = [], library = [], selectionSerial = 0, recordGeneration = 0, transcriptController = null; |
| let sendSerial = 0, activeSend = null, speech = { status: "idle" }, audioUrl = null, pendingSpeechFinish = null; |
| const safe = (fn) => async () => { |
| try { |
| await fn(); |
| } catch (error) { |
| notify(error.message); |
| } |
| }; |
| function draft(value) { |
| $("edit-prompt").value = value; |
| if ($("voice-transcript") && value) $("voice-transcript").textContent = "You: " + value; |
| onReadout({ draft: value }); |
| } |
| function renderConversation(entry) { |
| messages = entry.messages || []; |
| $("chat-messages").replaceChildren(); |
| for (const message of messages.slice(-12)) { |
| const bubble = document.createElement("div"); |
| bubble.className = "chat-bubble " + message.role; |
| const label = document.createElement("small"); |
| label.textContent = message.role === "user" ? "You" : "Agent"; |
| const text = document.createElement("div"); |
| text.textContent = message.content; |
| bubble.append(label, text); |
| $("chat-messages").append(bubble); |
| } |
| $("chat-messages").scrollTop = $("chat-messages").scrollHeight; |
| $("preferences").textContent = uiText(entry.preferences?.length ? "Saved preferences: " + entry.preferences.join("; ") : ""); |
| const last = messages.at(-1), userIndex = messages.findLastIndex((m) => m.role === "user"), reply = messages.slice(userIndex + 1).findLast((m) => m.role === "assistant"); |
| if (last) onReadout({ message: last.content, role: last.role, dialogue: { userText: userIndex >= 0 ? messages[userIndex].content : "", agentText: reply?.content || "" } }); |
| } |
| async function say(text) { |
| if (scriptedMode) return; |
| cancelSpeech(); |
| const generation = ++voiceGeneration; |
| const report = (status) => { |
| if (generation === voiceGeneration) { |
| speech = { status, text }; |
| onReadout({ speech }); |
| } |
| }; |
| if (!config || config.voice.provider === "off" || recordState !== "idle") { |
| report("skipped"); |
| return; |
| } |
| report("loading"); |
| const controller = new AbortController(); |
| let resolveCompletion, settled = false; |
| const completion = new Promise((resolve) => resolveCompletion = resolve); |
| const finish = (status) => { |
| if (settled) return; |
| settled = true; |
| clearTimeout(timer); |
| if (status !== "completed") controller.abort(); |
| report(status); |
| if (pendingSpeechFinish === finish) pendingSpeechFinish = null; |
| resolveCompletion(status); |
| }; |
| const timer = setTimeout(() => { |
| finish("failed"); |
| globalThis.speechSynthesis?.cancel(); |
| audioPlayer?.pause(); |
| notify("Speech timed out. The text reply is still available."); |
| }, 15e3); |
| pendingSpeechFinish = finish; |
| try { |
| if (config.voice.provider === "browser") { |
| if (!globalThis.speechSynthesis) { |
| finish("unavailable"); |
| return completion; |
| } |
| const utterance = new SpeechSynthesisUtterance(text); |
| const language = /\p{Script=Han}/u.test(text) ? "zh" : "en"; |
| utterance.lang = config.voice.language?.startsWith(language) ? config.voice.language : language === "zh" ? "zh-CN" : "en-US"; |
| const voice = speechSynthesis.getVoices().find((v) => v.lang.toLowerCase().startsWith(utterance.lang.toLowerCase().split("-")[0])); |
| if (voice) utterance.voice = voice; |
| utterance.onstart = () => report("speaking"); |
| utterance.onend = () => finish("completed"); |
| utterance.onerror = () => finish("failed"); |
| speechSynthesis.speak(utterance); |
| } else { |
| const response = await fetch("/api/speech/speak", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ text: text.slice(0, 1900) }), signal: controller.signal }); |
| if (!response.ok) throw new Error((await response.json()).error); |
| const blob = await response.blob(); |
| if (generation !== voiceGeneration || recordState !== "idle") { |
| finish("cancelled"); |
| return completion; |
| } |
| const url = URL.createObjectURL(blob); |
| audioUrl = url; |
| audioPlayer = new Audio(url); |
| audioPlayer.onended = () => { |
| URL.revokeObjectURL(url); |
| finish("completed"); |
| }; |
| audioPlayer.onerror = () => finish("failed"); |
| await audioPlayer.play(); |
| report("speaking"); |
| } |
| } catch (error) { |
| if (generation === voiceGeneration && !settled) notify("Text reply retained. Speech did not finish: " + error.message); |
| finish("failed"); |
| } |
| return completion; |
| } |
| function cancelSpeech() { |
| pendingSpeechFinish?.("cancelled"); |
| voiceGeneration++; |
| globalThis.speechSynthesis?.cancel(); |
| audioPlayer?.pause(); |
| if (audioUrl) { |
| URL.revokeObjectURL(audioUrl); |
| audioUrl = null; |
| } |
| if (["loading", "speaking"].includes(speech.status)) { |
| speech = { ...speech, status: "cancelled" }; |
| onReadout({ speech }); |
| } |
| } |
| async function confirmedSelection() { |
| if (scriptedMode) return; |
| const serial = ++selectionSerial, context = getContext(); |
| if (!context.ids.length) return; |
| const entry = await api("/api/conversation/select", { conversationId, ...context }); |
| if (serial !== selectionSerial) return; |
| renderConversation(entry); |
| } |
| async function sendText(value = $("edit-prompt").value, capturedContext = getContext()) { |
| if (scriptedMode) { |
| if (languagePattern("studio.cancel").test(value.trim())) { |
| getScripted()?.cancel(); |
| return; |
| } |
| throw new Error("Hold X to speak, then release"); |
| } |
| if (!value.trim()) throw new Error("Enter or speak your request first"); |
| if (activeSend !== null && !canInterrupt(value)) throw new Error("Processing the previous request. Please wait or say Stop."); |
| selectionSerial++; |
| const serial = ++sendSerial; |
| activeSend = serial; |
| const replies = []; |
| let published = false; |
| const publish = (reply, { speak = true } = {}) => { |
| if (serial !== sendSerial) return; |
| if (!/\p{Script=Han}/u.test(value)) reply = uiText(reply); |
| if (!published) { |
| messages.push({ role: "user", content: value }); |
| published = true; |
| } |
| replies.push(reply); |
| messages.push({ role: "assistant", content: reply }); |
| draft(""); |
| renderConversation({ messages }); |
| return speak ? say(reply) : void 0; |
| }; |
| if (voiceOnly) onReadout({ message: value, role: "user" }); |
| try { |
| const reply = await handleText(value, capturedContext, { publish }); |
| if (reply !== null) { |
| if (serial !== sendSerial || reply === void 0) return; |
| if (typeof reply === "string") publish(reply, { speak: replies.length === 0 }); |
| if (activeSend === serial) activeSend = null; |
| if (replies.length) try { |
| const entry = await api("/api/director-dialogue", { conversationId, text: value, reply: replies.join("\n") }); |
| if (serial === sendSerial) renderConversation(entry); |
| } catch { |
| notify("Text reply retained. Conversation history could not be saved."); |
| } |
| return; |
| } |
| if (getContext().busy) throw new Error("Finish the current request, voice input, or preview first"); |
| draft(""); |
| onReadout({ message: value, role: "user" }); |
| await requestJob("chat", value, conversationId, capturedContext); |
| } catch (error) { |
| if (serial === sendSerial) draft(value); |
| throw error; |
| } finally { |
| if (activeSend === serial) activeSend = null; |
| } |
| } |
| function voiceDraft() { |
| if (recordState !== "reviewing" || !pendingVoice) return null; |
| const pages = voicePages(pendingVoice.text); |
| return { text: pendingVoice.text, targetLabel: pendingVoice.context.targetLabel || "Current scene", page: reviewPage, pages: pages.length, pageText: pages[reviewPage], targetIds: pendingVoice.context.targetIds || [] }; |
| } |
| function paintRecording() { |
| const label = recordState === "recording" ? "■ Stop listening" : recordState === "reviewing" ? "● Speak again" : recordState === "transcribing" ? "Transcribing…" : recordState === "requesting" ? "Waiting for microphone…" : "● Start speaking"; |
| for (const id of ["voice-input", "voice-talk"]) if ($(id)) { |
| $(id).textContent = uiText(label); |
| $(id).disabled = ["requesting", "transcribing"].includes(recordState); |
| } |
| if ($("voice-status")) $("voice-status").textContent = uiText(recordState === "reviewing" ? "Review, then A / Enter Send · X Retry · B / Esc Cancel" : recordState === "idle" ? "Click to speak · Quest: hold X, release to review" : recordState === "recording" ? automatic ? "Listening · Review after speaking · B Cancel" : "Listening · Click to stop or release X" : "Processing voice…"); |
| onReadout({ recording: recordState, autoVoice: automatic, voiceDraft: voiceDraft() }); |
| } |
| function pageVoice(step) { |
| if (!voiceDraft()) return; |
| reviewPage = Math.max(0, Math.min(voicePages(pendingVoice.text).length - 1, reviewPage + step)); |
| paintRecording(); |
| } |
| async function confirmVoice() { |
| if (recordState !== "reviewing" || !pendingVoice) return; |
| const entry = pendingVoice; |
| validateVoiceContext(entry.context, getContext()); |
| pendingVoice = null; |
| recordState = "idle"; |
| reviewPage = 0; |
| paintRecording(); |
| if (entry.destination === "image") { |
| $("image-generation-prompt").value = entry.text; |
| return requestJob("image", entry.text, conversationId, entry.context); |
| } |
| if (entry.destination === "blueprint") { |
| $("blueprint-prompt").value = entry.text; |
| draft(""); |
| onReadout({ message: entry.text, role: "user" }); |
| notify("Requirements saved. Click Build after adding your photos."); |
| return; |
| } |
| return sendText(entry.text, entry.context); |
| } |
| let autoContext = null, autoTimer = null, automatic = false; |
| function stopAuto() { |
| clearInterval(autoTimer); |
| autoTimer = null; |
| autoContext?.close().catch(() => { |
| }); |
| autoContext = null; |
| } |
| async function startVoice({ destination = "agent", auto = false } = {}) { |
| if (scriptedMode) { |
| getScripted()?.press(); |
| return; |
| } |
| if (!["idle", "reviewing"].includes(recordState)) return; |
| const previous = pendingVoice; |
| const capturedContext = structuredClone(previous?.context || getContext()); |
| if (previous) { |
| validateVoiceContext(capturedContext, getContext()); |
| destination = previous.destination; |
| } |
| if (destination === "agent" && voiceOnly && capturedContext.phase === "reference") destination = "blueprint"; |
| if (destination === "agent" ? capturedContext.voiceBusy ?? capturedContext.busy : capturedContext.busy) throw new Error("Finish the current request, selection, or preview first"); |
| if (!mediaDevices?.getUserMedia || !globalThis.MediaRecorder) throw new Error("This browser cannot record audio. Open the local page in a browser with microphone support."); |
| automatic = auto; |
| onVoiceCapture(capturedContext); |
| const generation = ++recordGeneration; |
| stopRequested = false; |
| recordState = "requesting"; |
| paintRecording(); |
| cancelSpeech(); |
| try { |
| config = await api("/api/config"); |
| if (generation !== recordGeneration) return; |
| if (config.speech.provider === "openai" && !config.speech.hasKey) throw new Error("Add your OpenAI API key under Speech transcription in API settings"); |
| if (!config.speech.model?.trim()) throw new Error("Open API settings and enter a speech transcription model first"); |
| if (stopRequested) { |
| recordState = "idle"; |
| paintRecording(); |
| onVoiceFinish(); |
| return; |
| } |
| const activeStream = await mediaDevices.getUserMedia({ audio: { echoCancellation: true, noiseSuppression: true } }); |
| if (generation !== recordGeneration || stopRequested) { |
| activeStream.getTracks().forEach((t) => t.stop()); |
| if (generation === recordGeneration) { |
| recordState = "idle"; |
| paintRecording(); |
| onVoiceFinish(); |
| } |
| return; |
| } |
| stream = activeStream; |
| const mime = ["audio/webm;codecs=opus", "audio/webm", "audio/mp4"].find((t) => MediaRecorder.isTypeSupported(t)); |
| const activeRecorder = new MediaRecorder(activeStream, mime ? { mimeType: mime } : {}), recordChunks = []; |
| recorder = activeRecorder; |
| activeRecorder.ondataavailable = (event) => { |
| if (event.data.size) recordChunks.push(event.data); |
| }; |
| activeRecorder.onerror = () => { |
| if (generation === recordGeneration) { |
| cancelVoice(); |
| if (previous && voiceOnly) { |
| pendingVoice = previous; |
| recordState = "reviewing"; |
| draft(previous.text); |
| paintRecording(); |
| } |
| notify("Audio recording failed. Check microphone permission."); |
| } |
| }; |
| activeRecorder.onstop = async () => { |
| stopAuto(); |
| activeStream.getTracks().forEach((t) => t.stop()); |
| if (generation !== recordGeneration) return; |
| clearTimeout(recordTimer); |
| stream = null; |
| recordState = "transcribing"; |
| paintRecording(); |
| const controller = new AbortController(); |
| transcriptController = controller; |
| try { |
| const blob = new Blob(recordChunks, { type: activeRecorder.mimeType || "audio/webm" }), data = await blobData(blob); |
| const result = await api("/api/speech/transcribe", { audio: data.split(",")[1], mime: blob.type }, { signal: controller.signal }); |
| if (generation !== recordGeneration) return; |
| if (!result.text?.trim()) throw Error("No speech recognized. Please speak again."); |
| draft(result.text); |
| if (voiceOnly) { |
| pendingVoice = { text: result.text, context: capturedContext, destination }; |
| reviewPage = 0; |
| recordState = "reviewing"; |
| paintRecording(); |
| notify("Review transcript · A Send · X Retry · B Cancel"); |
| return; |
| } |
| recordState = "idle"; |
| paintRecording(); |
| if (destination === "image") { |
| $("image-generation-prompt").value = result.text; |
| await requestJob("image", result.text, conversationId, capturedContext); |
| } else if (destination === "blueprint") { |
| $("blueprint-prompt").value = result.text; |
| onReadout({ message: result.text, role: "user" }); |
| notify("Requirements saved. Click Build after adding your photos."); |
| } else await sendText(result.text, capturedContext); |
| } catch (error) { |
| if (generation === recordGeneration) notify(error.message); |
| } finally { |
| if (generation === recordGeneration) { |
| onVoiceFinish(); |
| recordState = pendingVoice ? "reviewing" : "idle"; |
| paintRecording(); |
| recorder = null; |
| transcriptController = null; |
| } |
| } |
| }; |
| activeRecorder.start(); |
| recordState = "recording"; |
| paintRecording(); |
| recordTimer = setTimeout(stopVoice, 3e4); |
| if (auto) { |
| const Audio2 = globalThis.AudioContext || globalThis.webkitAudioContext; |
| if (!Audio2) throw Error("Automatic speech detection is unavailable in this browser."); |
| autoContext = new Audio2(); |
| await autoContext.resume(); |
| if (generation !== recordGeneration) { |
| stopAuto(); |
| return; |
| } |
| const analyser = autoContext.createAnalyser(); |
| analyser.fftSize = 1024; |
| autoContext.createMediaStreamSource(activeStream).connect(analyser); |
| const buffer = new Float32Array(analyser.fftSize), endpoint = createSpeechEndpoint(); |
| autoTimer = setInterval(() => { |
| if (generation !== recordGeneration) return stopAuto(); |
| analyser.getFloatTimeDomainData(buffer); |
| const rms = Math.sqrt(buffer.reduce((sum, v) => sum + v * v, 0) / buffer.length), decision = endpoint.sample(performance.now(), rms); |
| if (decision === "send") stopVoice(); |
| if (decision === "cancel") { |
| cancelVoice(); |
| notify("No speech detected. Choose Other to try again."); |
| } |
| }, 40); |
| notify(voiceOnly ? "Listening · Review after speaking · B Cancel" : "Listening · Sends after speaking · B Cancel"); |
| } |
| } catch (error) { |
| if (generation !== recordGeneration) return; |
| cancelVoice(); |
| if (previous && voiceOnly) { |
| pendingVoice = previous; |
| recordState = "reviewing"; |
| draft(previous.text); |
| paintRecording(); |
| } |
| throw new Error("Voice input unavailable: " + error.message); |
| } |
| } |
| function stopVoice() { |
| if (scriptedMode) return getScripted()?.release(); |
| stopRequested = true; |
| if (recorder?.state === "recording") recorder.stop(); |
| } |
| function cancelVoice() { |
| stopAuto(); |
| if (scriptedMode) getScripted()?.cancel(); |
| onVoiceFinish(); |
| recordGeneration++; |
| stopRequested = true; |
| clearTimeout(recordTimer); |
| transcriptController?.abort(); |
| transcriptController = null; |
| if (recorder?.state === "recording") recorder.stop(); |
| recorder = null; |
| stream?.getTracks().forEach((t) => t.stop()); |
| stream = null; |
| pendingVoice = null; |
| reviewPage = 0; |
| recordState = "idle"; |
| if (voiceOnly) draft(""); |
| paintRecording(); |
| cancelSpeech(); |
| } |
| const roleLabels = { speech: "Speech transcription", voice: "Spoken replies", analysis: "Conversation and preferences", construction: "3D scene construction", images: "Image generation" }; |
| const choices = { speech: [["openai", "OpenAI (default)"], ["openai-compatible", "Other compatible API"]], voice: [["browser", "Browser speech"], ["openai", "OpenAI"], ["openai-compatible", "Other compatible API"], ["off", "Off"]], analysis: [["codex", "Local Codex"], ["openai-compatible", "OpenAI-compatible API"]], construction: [["codex", "Local Codex"], ["openai-compatible", "OpenAI-compatible API"]], images: [["disabled", "Disabled"], ["openai-compatible", "OpenAI Images-compatible API"]] }; |
| function renderConfig() { |
| $("provider-fields").replaceChildren(); |
| for (const [role, label] of Object.entries(roleLabels)) { |
| const fieldset = document.createElement("fieldset"); |
| fieldset.dataset.role = role; |
| const legend = document.createElement("legend"); |
| legend.textContent = uiText(label); |
| fieldset.append(legend); |
| const select = document.createElement("select"); |
| select.name = "provider"; |
| select.setAttribute("aria-label", uiText(label + " protocol")); |
| for (const [value, name] of choices[role]) { |
| const option = document.createElement("option"); |
| option.value = value; |
| option.textContent = uiText(name); |
| select.append(option); |
| } |
| select.value = config[role].provider; |
| fieldset.append(select); |
| for (const [key, placeholder] of [["baseUrl", "API Base URL"], ["model", "Model name"], ...role === "voice" ? [["voice", "Voice ID, e.g. alloy"]] : [], ...["speech", "voice"].includes(role) ? [["language", "Language, e.g. en-US"]] : [], ["apiKey", config[role].hasKey ? "Key saved; leave blank to keep it" : "API Key"]]) { |
| const input = document.createElement("input"); |
| input.name = key; |
| input.type = key === "apiKey" ? "password" : "text"; |
| input.placeholder = uiText(placeholder); |
| input.setAttribute("aria-label", uiText(label + " " + key)); |
| input.autocomplete = "off"; |
| input.value = key === "apiKey" ? "" : config[role][key] || ""; |
| fieldset.append(input); |
| } |
| const clearLabel = document.createElement("label"), clear = document.createElement("input"); |
| clear.type = "checkbox"; |
| clear.name = "clearKey"; |
| clearLabel.append(clear, document.createTextNode(uiText("Clear saved key"))); |
| fieldset.append(clearLabel); |
| $("provider-fields").append(fieldset); |
| if (["speech", "voice"].includes(role)) { |
| const hint = document.createElement("p"); |
| hint.className = "muted"; |
| fieldset.append(hint); |
| const input = (name) => fieldset.querySelector(`[name="${name}"]`); |
| const updateHint = () => { |
| const official = select.value === "openai", remote = official || select.value === "openai-compatible", changed = select.value !== config[role].provider || input("baseUrl").value.trim().replace(/\/+$/, "") !== config[role].baseUrl; |
| input("baseUrl").readOnly = official; |
| input("baseUrl").placeholder = "API Base URL or full audio endpoint"; |
| input("language").placeholder = role === "speech" ? "Language: auto, en, zh (blank = auto)" : "Browser language, e.g. en-US"; |
| input("apiKey").placeholder = changed ? official ? "OpenAI API Key" : "Key for this service (if required)" : config[role].hasKey ? "Key saved; leave blank to keep it" : official ? "OpenAI API Key" : "API Key (if required)"; |
| hint.textContent = role === "speech" ? official ? "Uses OpenAI audio transcription. Enter your API key and choose a transcription model." : "Uses /audio/transcriptions. Enter your service URL and model ID; a key is optional for services without authentication." : remote ? "AI-generated voice. Uses /audio/speech with your model and voice ID." : "Browser speech needs no API key. Off disables spoken replies."; |
| if (changed) hint.textContent += " Changing the service clears its previously saved key."; |
| for (const name of ["baseUrl", "model", "voice", "apiKey"]) if (input(name)) input(name).disabled = role === "voice" && !remote; |
| }; |
| select.onchange = () => { |
| const custom = select.value === "openai-compatible"; |
| input("baseUrl").value = custom ? "" : "https://api.openai.com/v1"; |
| input("model").value = custom ? "" : role === "speech" ? "gpt-4o-mini-transcribe" : "gpt-4o-mini-tts"; |
| if (role === "voice") input("voice").value = custom ? "" : "alloy"; |
| input("language").value = role === "speech" ? "auto" : "zh-CN"; |
| input("apiKey").value = ""; |
| updateHint(); |
| }; |
| input("baseUrl").addEventListener("input", updateHint); |
| updateHint(); |
| } |
| } |
| } |
| async function saveSettings() { |
| const update = {}; |
| for (const fieldset of $("provider-fields").children) { |
| const fields = {}; |
| for (const input of fieldset.querySelectorAll("input,select")) fields[input.name] = input.type === "checkbox" ? input.checked : input.value; |
| update[fieldset.dataset.role] = fields; |
| } |
| config = await api("/api/config", update); |
| renderConfig(); |
| $("settings-dialog").close(); |
| notify("API settings saved locally"); |
| } |
| async function refreshLibrary() { |
| library = await api("/api/library"); |
| $("image-library").replaceChildren(); |
| for (const item of library) { |
| const card = document.createElement("button"); |
| card.className = "image-card"; |
| card.dataset.id = item.id; |
| const image = document.createElement("img"); |
| image.src = item.url; |
| image.alt = uiText(item.title); |
| const title = document.createElement("span"); |
| title.textContent = uiText(item.title); |
| const tag = document.createElement("small"); |
| tag.textContent = uiText(item.kind === "preset" ? "Preset reference" : "Generated image"); |
| card.append(image, title, tag); |
| card.onclick = () => chooseReference(item.id); |
| $("image-library").append(card); |
| } |
| onLibrary(library); |
| return library; |
| } |
| function chooseReference(id) { |
| const item = library.find((i) => i.id === id); |
| if (!item) return; |
| onReference(item); |
| document.querySelectorAll(".image-card").forEach((card) => card.classList.toggle("selected", card.dataset.id === id)); |
| $("image-preview").src = item.url; |
| $("image-preview").hidden = false; |
| $("image-name").textContent = uiText("Selected: " + item.title); |
| notify("Reference selected: " + item.title); |
| } |
| $("settings-open").onclick = safe(async () => { |
| config = await api("/api/config"); |
| renderConfig(); |
| $("settings-dialog").showModal(); |
| }); |
| $("settings-close").onclick = () => $("settings-dialog").close(); |
| $("settings-save").onclick = safe(saveSettings); |
| $("voice-input").onclick = safe(() => recordState === "recording" ? stopVoice() : startVoice()); |
| $("ask-codex").onclick = safe(() => sendText()); |
| $("edit-prompt").oninput = () => onReadout({ draft: $("edit-prompt").value }); |
| if ($("voice-talk")) $("voice-talk").onclick = $("voice-input").onclick; |
| if ($("image-voice")) $("image-voice").onclick = safe(() => recordState === "recording" ? stopVoice() : startVoice({ destination: "image" })); |
| if ($("conversation-toggle")) $("conversation-toggle").onclick = () => { |
| const open = !$("text-input").open; |
| $("text-input").open = open; |
| $("conversation-toggle").setAttribute("aria-expanded", String(open)); |
| }; |
| $("generate-image").onclick = safe(() => requestJob("image", $("image-generation-prompt").value, conversationId)); |
| addEventListener("pagehide", cancelVoice); |
| async function initialize({ loadLibrary = true } = {}) { |
| if (scriptedMode) { |
| if (loadLibrary) await refreshLibrary(); |
| return; |
| } |
| config = await api("/api/config"); |
| renderConfig(); |
| if (loadLibrary) await refreshLibrary(); |
| renderConversation(await api("/api/conversation?id=" + conversationId)); |
| } |
| return { initialize, conversationId, confirmedSelection, renderConversation, refreshLibrary, chooseReference, say, startVoice, stopVoice, cancelVoice, confirmVoice, pageVoice, getVoiceDraft: voiceDraft, getSpeechState: () => ({ ...speech, automatic: automatic && recordState !== "idle" }), getRecordingState: () => recordState, getDraft: () => $("edit-prompt").value, setDraft: draft, sendText }; |
| } |
| export { |
| createStudio |
| }; |
|
|
