@bivy/bivy 0.0.0 → 0.1.0-staging.11

package/dist/session/transcript-normal.js

@@ -0,0 +1,195 @@
+/** Cap a tool payload down to a short, log-safe one-liner. */
+function compactValue(value, max = 200) {
+    let s;
+    try {
+        s = typeof value === "string" ? value : JSON.stringify(value);
+    }
+    catch {
+        s = String(value);
+    }
+    s = String(s ?? "").replace(/\s+/g, " ").trim();
+    return s.length > max ? `${s.slice(0, Math.max(0, max - 1))}…` : s;
+}
+/** Flatten one runtime message's content into text + tool annotations. */
+function readContent(content) {
+    if (typeof content === "string") {
+        return { text: content, tools: [], toolResultOnly: false };
+    }
+    if (!Array.isArray(content)) {
+        return { text: "", tools: [], toolResultOnly: false };
+    }
+    const texts = [];
+    const tools = [];
+    let sawText = false;
+    let sawToolResult = false;
+    for (const raw of content) {
+        const type = raw?.type;
+        if (type === "text" && typeof raw.text === "string") {
+            texts.push(raw.text);
+            sawText = true;
+        }
+        else if (type === "tool_use") {
+            tools.push({ name: raw.name, summary: `${raw.name ?? "tool"}(${compactValue(raw.input)})` });
+        }
+        else if (type === "tool_result") {
+            sawToolResult = true;
+            tools.push({ name: undefined, summary: `→ ${compactValue(raw.content)}` });
+        }
+        // "thinking" and unknown block types are intentionally dropped: internal
+        // reasoning is neither portable across runtimes nor needed for continuity.
+    }
+    return { text: texts.join("\n").trim(), tools, toolResultOnly: sawToolResult && !sawText };
+}
+function normalizeRole(role, toolResultOnly) {
+    if (role === "assistant")
+        return "assistant";
+    if (role === "system" || role === "error")
+        return "error";
+    // A "user" message that is purely tool_result is really tool output.
+    if (role === "user")
+        return toolResultOnly ? "tool" : "user";
+    return "user";
+}
+function toTs(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string") {
+        const t = Date.parse(value);
+        if (!Number.isNaN(t))
+            return t;
+    }
+    return undefined;
+}
+/**
+ * Flatten a runtime transcript (`readMessages()` output) into portable turns.
+ * Pure and defensive: unknown shapes degrade to empty text rather than throwing.
+ */
+export function normalizeMessages(messages, header) {
+    const turns = [];
+    for (const message of messages ?? []) {
+        const m = message;
+        const { text, tools, toolResultOnly } = readContent(m.content);
+        const role = normalizeRole(m.role, toolResultOnly);
+        const namedTool = tools.find((t) => t.name)?.name;
+        const toolSummary = tools.length ? tools.map((t) => t.summary).join("; ") : undefined;
+        // Skip turns that carry nothing a destination could use.
+        if (!text && !toolSummary)
+            continue;
+        turns.push({
+            role,
+            text,
+            ...(namedTool ? { toolName: namedTool } : {}),
+            ...(toolSummary ? { toolSummary } : {}),
+            ...(toTs(m.timestamp ?? m.ts) !== undefined ? { ts: toTs(m.timestamp ?? m.ts) } : {}),
+        });
+    }
+    return { header, turns };
+}
+function truncate(text, max) {
+    const compact = String(text || "").replace(/\s+/g, " ").trim();
+    return compact.length > max ? `${compact.slice(0, Math.max(0, max - 1))}…` : compact;
+}
+/**
+ * Render a continuation prompt for a **seeded** (cross-runtime) fork — the
+ * fallback when the target runtime can't replay history into its own store.
+ *
+ * The recent-conversation block is **budget-adaptive**, not a fixed tail: it
+ * walks backward from the latest turn packing verbatim turns until `charBudget`
+ * is reached (or the optional `recentTurns` count cap is hit), so a long run of
+ * short turns carries far more context than the old fixed 12, while a few
+ * verbose turns still stay bounded for the target's context window and cost. Any
+ * turns that don't fit are summarised as an omission count that points at the
+ * full transcript — the complete history is one link away. A structured superset
+ * of the old client-side `sessionHandoffSummary`.
+ */
+export function buildSeedPrompt(transcript, opts = {}) {
+    const perTurnChars = opts.perTurnChars ?? 700;
+    const charBudget = opts.charBudget ?? 12000;
+    const maxCount = opts.recentTurns ?? Number.POSITIVE_INFINITY;
+    const title = transcript.header.title || "Untitled session";
+    const targetAgent = opts.targetAgent || "a new agent";
+    const formatted = transcript.turns
+        .filter((t) => t.text || t.toolSummary)
+        .map((t) => {
+        const body = t.text || (t.toolSummary ? `[${t.toolName ?? "tool"}] ${t.toolSummary}` : "");
+        return `- ${t.role}: ${truncate(body, perTurnChars)}`;
+    });
+    // Pack the newest turns first, within both the char budget and the count cap.
+    // The most recent turn is always kept, even if it alone exceeds the budget, so
+    // the seed is never empty.
+    const picked = [];
+    let used = 0;
+    for (let i = formatted.length - 1; i >= 0 && picked.length < maxCount; i -= 1) {
+        const cost = formatted[i].length + 1;
+        if (picked.length > 0 && used + cost > charBudget)
+            break;
+        picked.push(formatted[i]);
+        used += cost;
+    }
+    picked.reverse();
+    const omitted = formatted.length - picked.length;
+    const recent = picked.length ? picked.join("\n") : "- (no prior turns were available)";
+    const lines = [
+        `I am continuing an existing Bivy session (forked from ${transcript.header.sourceRuntimeId} to ${targetAgent}).`,
+        `Session: ${title}`,
+        opts.transcriptUrl ? `Full original transcript: ${opts.transcriptUrl}` : null,
+        transcript.header.model ? `Model before fork: ${transcript.header.model}` : null,
+        opts.context?.repoSlug ? `Repository: ${opts.context.repoSlug}` : null,
+        opts.context?.branch ? `Branch: ${opts.context.branch}` : null,
+        opts.context?.prUrl ? `PR: ${opts.context.prUrl}` : null,
+        "",
+        omitted > 0
+            ? `Recent conversation (most recent last; ${omitted} earlier turn${omitted === 1 ? "" : "s"} omitted — see the full transcript${opts.transcriptUrl ? " linked above" : ""}):`
+            : "Recent conversation (most recent last):",
+        recent,
+        "",
+        opts.transcriptUrl
+            ? "Open the full transcript link above if this summary is missing anything, then continue from here."
+            : "Continue from here.",
+    ];
+    return lines.filter((line) => line != null).join("\n");
+}
+/**
+ * Render a normalized transcript as portable `{role, text}` turns for a
+ * **replayed** ("true fork") cross-runtime fork — the target runtime writes
+ * these as real prior conversation into its own store and resumes, so the new
+ * agent opens on a copy of the whole history instead of a seeded summary.
+ *
+ * Unlike `buildSeedPrompt` this keeps EVERY turn, not just the tail, and keeps
+ * each turn's own role instead of flattening the conversation into one user
+ * prompt. Two deliberate shaping rules keep the result valid on any target model:
+ *   - Tool activity is inlined as plain text (`[ran X] …`, `[tool result] …`),
+ *     never as provider-specific `tool_use`/`tool_result` blocks whose ids/schemas
+ *     would dangle or mismatch in a different runtime.
+ *   - Non-conversational roles fold into the model's voice: a pure tool-result
+ *     turn and a system/error notice both attach as `assistant` text (the agent's
+ *     own work), so only the human's turns ever carry the `user` role.
+ * Consecutive same-role turns are merged so the resumed history reads as clean
+ * alternating turns. Tool payloads inherit `normalizeMessages`' compaction, so a
+ * replayed fork is faithful in its prose but summarised in raw tool I/O — the
+ * working tree (carried separately as a dirty patch) holds the real file state.
+ */
+export function buildForkHistory(transcript) {
+    const history = [];
+    for (const turn of transcript.turns) {
+        const role = turn.role === "user" ? "user" : "assistant";
+        const parts = [];
+        if (turn.role === "error" && turn.text)
+            parts.push(`[system] ${turn.text}`);
+        else if (turn.text)
+            parts.push(turn.text);
+        if (turn.toolSummary) {
+            const label = turn.role === "tool" ? "tool result" : turn.toolName ? `ran ${turn.toolName}` : "tool";
+            parts.push(`[${label}] ${turn.toolSummary}`);
+        }
+        const text = parts.join("\n\n").trim();
+        if (!text)
+            continue;
+        const last = history[history.length - 1];
+        if (last && last.role === role)
+            last.text = `${last.text}\n\n${text}`;
+        else
+            history.push({ role, text });
+    }
+    return history;
+}

package/dist/session/workspace-context.js

@@ -0,0 +1 @@
+export {};

package/dist/session-event-coalescer.js

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+const defaultTimers = {
+    schedule: (fn, ms) => setTimeout(fn, ms),
+    cancel: (h) => clearTimeout(h),
+};
+export class SessionEventCoalescer {
+    pending = new Map();
+    timers = new Map();
+    coalesceMs;
+    emit;
+    clock;
+    constructor(opts) {
+        this.coalesceMs = opts.coalesceMs;
+        this.emit = opts.emit;
+        this.clock = opts.timers ?? defaultTimers;
+    }
+    /** Queue a self-superseding update for `sessionId`, replacing any pending one. */
+    push(sessionId, payload) {
+        this.pending.set(sessionId, payload);
+        if (!this.timers.has(sessionId)) {
+            this.timers.set(sessionId, this.clock.schedule(() => this.flush(sessionId), this.coalesceMs));
+        }
+    }
+    /** Emit the pending update for `sessionId` immediately, if any. */
+    flush(sessionId) {
+        this.cancelTimer(sessionId);
+        if (this.pending.has(sessionId)) {
+            const payload = this.pending.get(sessionId);
+            this.pending.delete(sessionId);
+            this.emit(payload);
+        }
+    }
+    /** Drop any pending update and timer for `sessionId` without emitting (teardown). */
+    clear(sessionId) {
+        this.cancelTimer(sessionId);
+        this.pending.delete(sessionId);
+    }
+    /** Number of sessions with a pending update (test/introspection aid). */
+    get size() {
+        return this.pending.size;
+    }
+    cancelTimer(sessionId) {
+        const handle = this.timers.get(sessionId);
+        if (handle !== undefined) {
+            this.clock.cancel(handle);
+            this.timers.delete(sessionId);
+        }
+    }
+}

package/dist/session-identity.js

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+import path from "node:path";
+/**
+ * The identity key two rows share iff they're the same durable conversation: a
+ * resolved on-disk path when known (so relative/absolute spellings of the same
+ * file collapse together), else the bare id. Shared by dedupeSessionSummaries
+ * below and by native-session-discovery.ts's cross-check against Bivy-managed
+ * sessions (issue #156) — one identity scheme, not two copies of it.
+ */
+export function sessionIdentityKey(ref) {
+    return ref.path ? `ref:${path.resolve(ref.path)}` : `id:${ref.id}`;
+}
+/** Collapse adapter-local rows that point at the same durable conversation. */
+export function dedupeSessionSummaries(sessions, ownerFor) {
+    const byIdentity = new Map();
+    for (const session of sessions) {
+        const owner = ownerFor(session);
+        const ref = owner?.path || session.path;
+        const identity = sessionIdentityKey(ref ? { path: ref } : { id: session.id });
+        const current = byIdentity.get(identity);
+        if (!current) {
+            byIdentity.set(identity, session);
+            continue;
+        }
+        const score = (candidate) => {
+            const candidateOwner = ownerFor(candidate);
+            return Number(candidateOwner?.id === candidate.id) * 2 + Number(candidateOwner?.runtimeId === candidate.agent);
+        };
+        if (score(session) > score(current))
+            byIdentity.set(identity, session);
+    }
+    return [...byIdentity.values()];
+}

package/dist/session-ref.js

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+import path from "node:path";
+/**
+ * Reduce an id-based runtime's resume ref to the bare session id it expects.
+ *
+ * A ref may arrive as the id itself (the common case — e.g. straight from Bivy's
+ * metadata store) or, for adapters that surface an on-disk transcript path, as a
+ * ".../<id>.jsonl" file (Claude Code lists sessions from ~/.claude that way). Both
+ * normalize to "<id>".
+ */
+export function sessionIdFromRef(ref) {
+    return /[/\\]|\.jsonl$/i.test(ref) ? path.basename(ref).replace(/\.jsonl$/i, "") : ref;
+}
+/**
+ * Normalize a resume ref into the token the owning runtime actually expects,
+ * enforcing the sessions-dir guard only where it applies.
+ *
+ * Bivy is the unifying store for sessions started anywhere, so resume must work
+ * for every runtime — but runtimes differ in what a "session ref" is:
+ *
+ *   - Path-based runtimes (pi) resume by reading a transcript file. The daemon
+ *     can be handed an arbitrary path by a remote client, so these refs are
+ *     confined to the node's sessions directory (path-traversal guard).
+ *   - Id-based runtimes (Claude Code, …) resume by an opaque session id they
+ *     validate themselves and store their transcripts elsewhere (~/.claude).
+ *     There is no local file to confine, so the guard must NOT apply — doing so
+ *     is what made those sessions fail with "Session file is outside the
+ *     sessions directory".
+ *
+ * Throws for a path-based ref that escapes `sessionsDir`.
+ */
+export function resolveResumeRef(opts) {
+    const { ref, resumesByPath, sessionsDir } = opts;
+    if (!resumesByPath)
+        return sessionIdFromRef(ref);
+    const resolved = path.resolve(ref);
+    if (!resolved.startsWith(path.resolve(sessionsDir) + path.sep)) {
+        throw new Error("Session file is outside the sessions directory");
+    }
+    return resolved;
+}
+/**
+ * Decide what to resume a client-named session from when the node isn't holding
+ * it in memory (a restart, an idle close, or a session this process never
+ * opened — the PWA lists sessions straight from durable metadata). Prefer an
+ * explicit transcript path, then the path metadata recorded, and finally — for
+ * id-based runtimes that keep no confinable local file — the session id itself.
+ *
+ * Returns undefined when nothing durable is known: a session this node never
+ * started, or one that was deleted. The caller turns that into "Session not
+ * found" rather than resurrecting a bogus session from an arbitrary id. This is
+ * the decision that lets a real-but-closed session resume instead of failing —
+ * the root of the PWA's "can't resume sessions / sessions not found".
+ */
+export function resumeRefFor(opts) {
+    const explicit = opts.path?.trim();
+    if (explicit)
+        return explicit;
+    if (opts.metaPath)
+        return opts.metaPath;
+    if (opts.metaKnown && opts.id)
+        return opts.id;
+    return undefined;
+}

package/dist/stt-cli.js

@@ -0,0 +1,131 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+// `bivy voice` — configure speech-to-text (voice input) from the terminal.
+//
+// Mirrors the web app's Settings → Voice input panel: pick a preferred provider
+// and store a per-provider API key (encrypted in the SecretVault). Keeps CLI and
+// React in parity via the shared helpers in stt.ts.
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { STT_PROVIDERS, getSttConfig, isSttProvider, removeSttKey, resolveSttKey, setSttKey, setSttProvider, sttProviderList, } from "./stt.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(__dirname, "..");
+const appDir = process.env.BIVY_DATA_DIR ?? path.join(repoRoot, ".bivy");
+async function askHidden(question) {
+    if (!input.isTTY) {
+        const rl = createInterface({ input, output });
+        try {
+            return await rl.question(question);
+        }
+        finally {
+            rl.close();
+        }
+    }
+    return new Promise((resolve, reject) => {
+        let value = "";
+        const onData = (chunk) => {
+            for (const char of chunk.toString("utf8")) {
+                if (char === "\u0003") {
+                    cleanup();
+                    output.write("\n");
+                    reject(new Error("Cancelled"));
+                    return;
+                }
+                if (char === "\r" || char === "\n") {
+                    cleanup();
+                    output.write("\n");
+                    resolve(value);
+                    return;
+                }
+                if (char === "\u007f" || char === "\b")
+                    value = value.slice(0, -1);
+                else
+                    value += char;
+            }
+        };
+        const cleanup = () => {
+            input.off("data", onData);
+            input.setRawMode(false);
+            input.pause();
+        };
+        output.write(question);
+        input.setRawMode(true);
+        input.resume();
+        input.on("data", onData);
+    });
+}
+function usage() {
+    console.log(`Usage: bivy voice <status|provider|key|remove>
+
+Commands:
+  bivy voice                         Show the current provider and which keys are set
+  bivy voice status                  (same as above)
+  bivy voice provider <groq|openai>  Choose the preferred transcription provider
+  bivy voice key <groq|openai> [key] Store an API key (prompts when the key is omitted)
+  bivy voice remove <groq|openai>    Forget a stored API key
+
+Providers:
+  groq     ${STT_PROVIDERS.groq.model} — fast, low cost, strong multilingual
+  openai   ${STT_PROVIDERS.openai.model} — top accuracy
+`);
+}
+function parseProvider(value) {
+    if (!isSttProvider(value)) {
+        throw new Error(`Provider must be one of: ${sttProviderList().join(", ")}`);
+    }
+    return value;
+}
+async function printStatus() {
+    const config = await getSttConfig(appDir);
+    console.log(`Preferred provider: ${config.provider}`);
+    for (const p of config.providers) {
+        const active = p.id === config.provider ? " (preferred)" : "";
+        console.log(`  ${p.configured ? "✓" : "·"} ${p.id.padEnd(7)} ${p.label} — ${p.model}${active}`);
+    }
+    console.log(config.providers.some((p) => p.configured)
+        ? ""
+        : "\nNo keys set yet. Run 'bivy voice key groq' or 'bivy voice key openai'.");
+}
+async function main() {
+    const [cmd, arg, ...rest] = process.argv.slice(2);
+    if (!cmd || cmd === "help" || cmd === "--help" || cmd === "-h") {
+        usage();
+        return;
+    }
+    switch (cmd) {
+        case "status":
+            await printStatus();
+            return;
+        case "provider": {
+            const provider = parseProvider(arg);
+            setSttProvider(appDir, provider);
+            console.log(`Preferred voice provider set to ${provider}.`);
+            if (!(await resolveSttKey(appDir, provider))) {
+                console.log(`No key stored for ${provider} yet — run 'bivy voice key ${provider}'.`);
+            }
+            return;
+        }
+        case "key": {
+            const provider = parseProvider(arg);
+            const value = rest.join(" ").trim() || (await askHidden(`${STT_PROVIDERS[provider].label} API key: `));
+            setSttKey(appDir, provider, value);
+            console.log(`Saved ${provider} key.`);
+            return;
+        }
+        case "remove": {
+            const provider = parseProvider(arg);
+            console.log(removeSttKey(appDir, provider) ? `Removed ${provider} key.` : `No ${provider} key was stored.`);
+            return;
+        }
+        default:
+            console.error(`Unknown command: ${cmd}\n`);
+            usage();
+            process.exitCode = 1;
+    }
+}
+main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

package/dist/stt.js

@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+// Speech-to-text (voice input) — shared logic for the node server and the CLI.
+//
+// A voice recording captured in the web app (or any client) is forwarded to the
+// node, which holds the provider API key and makes the transcription call on the
+// user's behalf. Two providers are supported; the user picks a preferred one and
+// stores a key per provider. Keys live in the encrypted SecretVault (never in
+// settings.json); the preferred provider is a plain setting.
+//
+// Both providers expose the same OpenAI-compatible /audio/transcriptions
+// multipart endpoint that returns `{ text }`, which keeps the call site uniform.
+import fs from "node:fs";
+import path from "node:path";
+import { SecretVault } from "./secrets.js";
+export const STT_PROVIDERS = {
+    groq: {
+        id: "groq",
+        label: "Groq (Whisper)",
+        url: "https://api.groq.com/openai/v1/audio/transcriptions",
+        model: "whisper-large-v3-turbo",
+        keyEnv: "GROQ_API_KEY",
+    },
+    openai: {
+        id: "openai",
+        label: "OpenAI",
+        url: "https://api.openai.com/v1/audio/transcriptions",
+        model: "gpt-4o-mini-transcribe",
+        keyEnv: "OPENAI_API_KEY",
+    },
+};
+export const DEFAULT_STT_PROVIDER = "groq";
+/** Max audio payload we forward to a provider (their own caps are ~25 MB). */
+export const MAX_AUDIO_BYTES = 25 * 1024 * 1024;
+export function isSttProvider(value) {
+    return value === "groq" || value === "openai";
+}
+export function sttProviderList() {
+    return Object.keys(STT_PROVIDERS);
+}
+/** Vault secret id holding a provider's API key. */
+export function sttKeyId(provider) {
+    return `stt.${provider}`;
+}
+function settingsPath(appDir) {
+    return path.join(appDir, "settings.json");
+}
+function readSettings(appDir) {
+    try {
+        const file = settingsPath(appDir);
+        return fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, "utf8")) : {};
+    }
+    catch {
+        return {};
+    }
+}
+// Read-modify-write so we never clobber unrelated settings (approvalMode, etc.).
+function writeSettings(appDir, settings) {
+    fs.mkdirSync(appDir, { recursive: true });
+    fs.writeFileSync(settingsPath(appDir), `${JSON.stringify(settings, null, 2)}\n`);
+}
+export function getSttProvider(appDir) {
+    const raw = readSettings(appDir).sttProvider;
+    return isSttProvider(raw) ? raw : DEFAULT_STT_PROVIDER;
+}
+export function setSttProvider(appDir, provider) {
+    if (!isSttProvider(provider))
+        throw new Error(`Unknown speech provider: ${provider}`);
+    const settings = readSettings(appDir);
+    settings.sttProvider = provider;
+    writeSettings(appDir, settings);
+    return provider;
+}
+/** Resolve a provider key: stored vault secret first, then env-var fallback. */
+export async function resolveSttKey(appDir, provider) {
+    const fromVault = await new SecretVault(appDir).resolve(sttKeyId(provider)).catch(() => undefined);
+    if (fromVault)
+        return fromVault;
+    const env = process.env[STT_PROVIDERS[provider].keyEnv];
+    return env && env.trim() ? env.trim() : undefined;
+}
+export function setSttKey(appDir, provider, key) {
+    if (!isSttProvider(provider))
+        throw new Error(`Unknown speech provider: ${provider}`);
+    const value = String(key || "").trim();
+    if (!value)
+        throw new Error("API key cannot be empty.");
+    new SecretVault(appDir).setLocal(sttKeyId(provider), value, `${STT_PROVIDERS[provider].label} speech-to-text key`);
+}
+export function removeSttKey(appDir, provider) {
+    if (!isSttProvider(provider))
+        throw new Error(`Unknown speech provider: ${provider}`);
+    return new SecretVault(appDir).delete(sttKeyId(provider));
+}
+/** The voice-input status the settings UIs render: chosen provider + which keys exist. */
+export async function getSttConfig(appDir) {
+    const provider = getSttProvider(appDir);
+    const providers = await Promise.all(sttProviderList().map(async (id) => ({
+        id,
+        label: STT_PROVIDERS[id].label,
+        model: STT_PROVIDERS[id].model,
+        configured: Boolean(await resolveSttKey(appDir, id)),
+    })));
+    return { provider, providers };
+}
+/** Send audio to the chosen provider and return the transcript text. */
+export async function transcribeAudio(input) {
+    const provider = isSttProvider(input.provider) ? input.provider : getSttProvider(input.appDir);
+    const spec = STT_PROVIDERS[provider];
+    if (!input.audio || input.audio.length === 0)
+        throw new Error("No audio was recorded.");
+    if (input.audio.length > MAX_AUDIO_BYTES)
+        throw new Error("Recording is too large to transcribe.");
+    const key = await resolveSttKey(input.appDir, provider);
+    if (!key) {
+        throw new Error(`No API key set for ${spec.label}. Add one in Settings → Voice input, or run 'bivy voice key ${provider}'.`);
+    }
+    const mime = input.mimeType || "audio/webm";
+    const filename = input.filename || `audio.${extensionForMime(mime)}`;
+    const form = new FormData();
+    // Copy into a plain Uint8Array — a Node Buffer's backing store is typed as
+    // possibly-SharedArrayBuffer, which isn't a valid BlobPart under DOM lib types.
+    form.append("file", new Blob([new Uint8Array(input.audio)], { type: mime }), filename);
+    form.append("model", spec.model);
+    form.append("response_format", "json");
+    if (input.language)
+        form.append("language", input.language);
+    let res;
+    try {
+        res = await fetch(spec.url, { method: "POST", headers: { authorization: `Bearer ${key}` }, body: form });
+    }
+    catch (error) {
+        throw new Error(`Could not reach ${spec.label}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const body = await res.text();
+    if (!res.ok) {
+        let detail = body.slice(0, 300);
+        try {
+            detail = JSON.parse(body)?.error?.message || detail;
+        }
+        catch {
+            /* keep raw body */
+        }
+        throw new Error(`${spec.label} transcription failed (${res.status}): ${detail}`);
+    }
+    let data;
+    try {
+        data = JSON.parse(body);
+    }
+    catch {
+        throw new Error(`${spec.label} returned an unreadable response.`);
+    }
+    return String(data.text ?? "").trim();
+}
+function extensionForMime(mime) {
+    const m = mime.toLowerCase();
+    if (m.includes("webm"))
+        return "webm";
+    if (m.includes("ogg"))
+        return "ogg";
+    if (m.includes("mp4") || m.includes("m4a") || m.includes("aac"))
+        return "m4a";
+    if (m.includes("mpeg") || m.includes("mp3"))
+        return "mp3";
+    if (m.includes("wav"))
+        return "wav";
+    return "webm";
+}