opencaptions 1.2.1 → 1.3.1

package/dist/local/index.js

@@ -0,0 +1,213 @@
+/**
+ * Captioning on this computer, with no server: the speech model through sherpa-onnx, the engine's
+ * WebAssembly to draw, FFmpeg to read and write video. A project is a file beside the video
+ * (`<name>.opencaptions.json`: the transcript, the style and the offset), and its path is the
+ * project id the tools pass around. Everything is done before a call returns, so there are no
+ * tickets.
+ */
+import { readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, join, resolve } from "node:path";
+import { applyFixes, dealt, defaultOutput, styled, viewTranscript, } from "../captions.js";
+import { OpenCaptionsError } from "../client.js";
+import { Scene, subtitles } from "../engine.js";
+import formats from "../generated/render_formats.json" with { type: "json" };
+import { LOOKS } from "../looks.js";
+import { ensureFont } from "./fonts.js";
+import { encode, probe } from "./media.js";
+import { transcribe } from "./transcribe.js";
+const SIDECAR = ".opencaptions.json";
+async function read(id) {
+    try {
+        return JSON.parse(await readFile(id, "utf8"));
+    }
+    catch {
+        throw new OpenCaptionsError(`There is no OpenCaptions project at ${id}.`);
+    }
+}
+async function write(id, project) {
+    await writeFile(id, `${JSON.stringify(project, null, 2)}\n`);
+}
+async function open(source) {
+    if (/^https?:\/\//i.test(source)) {
+        throw new OpenCaptionsError("Without a server, the video has to be a file on this computer: download it first.");
+    }
+    const path = resolve(source);
+    if (!(await stat(path).catch(() => undefined))?.isFile()) {
+        throw new OpenCaptionsError(`There is no video at ${path}.`);
+    }
+    const id = join(dirname(path), `${basename(path, extname(path))}${SIDECAR}`);
+    const existing = await read(id).catch(() => undefined);
+    await write(id, {
+        version: 1,
+        source: path,
+        transcript: null,
+        style_config: existing?.style_config ?? null,
+        caption_offset_ms: 0,
+    });
+    return id;
+}
+// The output's size and frame rate from the source's, as the API decides them
+// (`resolve_render_inputs` in apps/api/app/services/render_formats.py).
+const SHORT_SIDES = { "2160": 2160, "1080": 1080, "720": 720 };
+const FRAME_RATES = { "30": 30, "60": 60 };
+/** Python's `round`: halves go to the even neighbour. */
+const round = (value) => {
+    const floor = Math.floor(value);
+    const diff = value - floor;
+    return diff > 0.5 || (diff === 0.5 && floor % 2 !== 0) ? floor + 1 : floor;
+};
+// Encoders need even dimensions in 4:2:0.
+const even = (value) => Math.max(2, round(value) & ~1);
+export function geometry(source, save) {
+    let { width, height } = source;
+    const target = SHORT_SIDES[save.resolution ?? "original"];
+    const short = Math.min(width, height);
+    if (target && target !== short) {
+        [width, height] = [even((width * target) / short), even((height * target) / short)];
+    }
+    const fps = FRAME_RATES[save.frame_rate ?? "original"] ?? Math.max(1, Math.min(60, source.fps));
+    return { width, height, fps: round(fps) };
+}
+function format(id = "mp4") {
+    const found = formats.find((f) => f.id === id);
+    if (!found) {
+        throw new OpenCaptionsError(`There is no format ${id}: ${formats.map((f) => f.id).join(", ")}.`);
+    }
+    return found;
+}
+/** Every family the style draws with: its own, and its word looks'. */
+function families(style) {
+    const variants = (style.variants ?? []);
+    return [style.font, ...variants.map((v) => v.font ?? "")].filter(Boolean);
+}
+async function saveVideo(project, options, progress) {
+    if (!project.transcript)
+        throw new OpenCaptionsError("This project has no captions yet.");
+    const fmt = format(options.format);
+    const info = await probe(project.source);
+    const { width, height, fps } = geometry(info, options);
+    const style = project.style_config ?? LOOKS[0]?.config;
+    for (const family of new Set(families(style)))
+        await ensureFont(family);
+    const output = options.output ?? `${defaultOutput(project.source, options.captions_only)}${fmt.extension}`;
+    const partial = `${output}.part${fmt.extension}`;
+    const scene = await Scene.create({
+        transcript: project.transcript,
+        style,
+        width,
+        height,
+        caption_offset_ms: project.caption_offset_ms,
+    });
+    try {
+        const plan = scene.plan({
+            source: project.source,
+            output: partial,
+            source_transfer: info.transfer,
+            duration: project.transcript.duration,
+            fps,
+            codec: fmt.codec,
+            crf: fmt.crf,
+            pro_res_profile: fmt.pro_res_profile,
+            green_screen: options.captions_only ?? false,
+        });
+        const [, , bw, bh] = plan.band;
+        await encode(plan.args, async (stdin) => {
+            let reported = 0;
+            // FFmpeg closes its input once it has the length it was asked for: that ends the writing.
+            let closed = false;
+            stdin.once("close", () => {
+                closed = true;
+            });
+            const room = () => new Promise((done) => {
+                const go = () => {
+                    stdin.off("drain", go);
+                    stdin.off("close", go);
+                    done();
+                };
+                stdin.on("drain", go);
+                stdin.on("close", go);
+            });
+            for (let i = 0; i < plan.frames && !closed; i++) {
+                const band = new Uint8Array(bw * bh * 4);
+                scene.band(i / fps, plan.band, band);
+                if (!stdin.write(band))
+                    await room();
+                const done = (i + 1) / plan.frames;
+                if (done - reported >= 0.05) {
+                    reported = done;
+                    progress(done, `Saving ${Math.round(done * 100)}%`);
+                }
+            }
+        });
+        await rename(partial, output);
+    }
+    catch (error) {
+        await rm(partial, { force: true });
+        throw error;
+    }
+    finally {
+        scene.free();
+    }
+    return output;
+}
+async function caption(request, progress) {
+    const id = await open(request.source);
+    const project = await read(id);
+    if (request.look !== undefined || request.style !== undefined) {
+        project.style_config = styled(project.style_config, request.look, request.style);
+    }
+    project.transcript =
+        request.transcript ??
+            (await transcribe(project.source, { language: request.language, model: request.model }, progress));
+    if (project.style_config) {
+        project.transcript =
+            (await dealt(project.transcript, project.style_config)) ?? project.transcript;
+    }
+    await write(id, project);
+    return { done: true, project_id: id, output: await saveVideo(project, request, progress) };
+}
+export function localCaptioner() {
+    return {
+        caption: (request, progress) => caption(request, progress),
+        resume: async () => {
+            throw new OpenCaptionsError("Without a server, every call finishes: there is nothing to resume.");
+        },
+        setStyle: async (id, look, changes) => {
+            const project = await read(id);
+            project.style_config = styled(project.style_config, look, changes);
+            if (look) {
+                project.transcript =
+                    (await dealt(project.transcript ?? undefined, project.style_config)) ??
+                        project.transcript;
+            }
+            await write(id, project);
+            return project.style_config;
+        },
+        readTranscript: async (id) => {
+            const project = await read(id);
+            return viewTranscript(project.transcript, project.style_config, project.caption_offset_ms);
+        },
+        fixWords: async (id, fixes) => {
+            const project = await read(id);
+            project.transcript = await applyFixes(project.transcript, fixes);
+            await write(id, project);
+            return fixes.length;
+        },
+        save: async (id, options, progress) => {
+            const output = await saveVideo(await read(id), options, progress);
+            return { done: true, project_id: id, output };
+        },
+        exportSubtitles: async (id, kind, output) => {
+            const project = await read(id);
+            if (!project.transcript)
+                throw new OpenCaptionsError("This project has no captions yet.");
+            const stem = output ?? defaultOutput(project.source);
+            const path = extname(stem) === `.${kind}` ? stem : `${stem}.${kind}`;
+            const body = kind === "json"
+                ? `${JSON.stringify(project.transcript, null, 2)}\n`
+                : await subtitles(project.transcript, project.style_config?.words_per_line ?? 3, project.caption_offset_ms, kind);
+            await writeFile(path, body);
+            return path;
+        },
+    };
+}

package/dist/local/media.js

@@ -0,0 +1,90 @@
+/**
+ * FFmpeg on this computer, for captioning without a server: what a video is, its sound as the
+ * speech model takes it, and the run that makes the captioned file (`encode::plan`'s command, with
+ * the caption band piped in). The probe reads what `apps/api/app/services/audio.py` reads.
+ */
+import { spawn } from "node:child_process";
+import { OpenCaptionsError } from "../client.js";
+const INSTALL = "FFmpeg is needed to caption without a server. Install it (macOS: brew install ffmpeg; " +
+    "Debian or Ubuntu: sudo apt install ffmpeg; Windows: winget install ffmpeg), or set " +
+    "OPENCAPTIONS_URL and OPENCAPTIONS_KEY to use an OpenCaptions server.";
+/** A program's output, or a clear error when it cannot be started or fails. */
+function run(program, args, input) {
+    return new Promise((done, fail) => {
+        const child = spawn(program, args, { stdio: [input ? "pipe" : "ignore", "pipe", "pipe"] });
+        const out = [];
+        const err = [];
+        child.stdout?.on("data", (chunk) => out.push(chunk));
+        child.stderr?.on("data", (chunk) => err.push(chunk));
+        child.on("error", (error) => fail(error.code === "ENOENT" ? new OpenCaptionsError(INSTALL) : error));
+        child.on("close", (code) => {
+            if (code === 0)
+                return done(Buffer.concat(out));
+            const why = Buffer.concat(err).toString().trim().split("\n").slice(-3).join(" ");
+            fail(new OpenCaptionsError(`${program} failed: ${why || `exit code ${code}`}`));
+        });
+        if (input && child.stdin) {
+            // FFmpeg closes its input once it has the length it was asked for: that ends the writing.
+            child.stdin.on("error", () => { });
+            input(child.stdin).then(() => child.stdin?.end(), (error) => {
+                child.kill();
+                fail(error);
+            });
+        }
+    });
+}
+const rate = (value) => {
+    const [n, d = "1"] = String(value ?? "").split("/");
+    const fps = Number(n) / Number(d);
+    return Number.isFinite(fps) && fps > 0 ? fps : undefined;
+};
+export async function probe(path) {
+    const raw = await run("ffprobe", [
+        "-v",
+        "error",
+        "-print_format",
+        "json",
+        "-show_streams",
+        "-show_format",
+        "-select_streams",
+        "v:0",
+        path,
+    ]);
+    const data = JSON.parse(raw.toString());
+    const stream = data.streams?.[0];
+    if (!stream?.width || !stream.height) {
+        throw new OpenCaptionsError(`${path} has no picture FFmpeg can read.`);
+    }
+    const matrix = stream.side_data_list?.find((s) => s.side_data_type === "Display Matrix");
+    const turn = ((Number(matrix?.rotation ?? stream.tags?.rotate ?? 0) % 360) + 360) % 360 || 0;
+    const [width, height] = turn === 90 || turn === 270 ? [stream.height, stream.width] : [stream.width, stream.height];
+    return {
+        width,
+        height,
+        fps: rate(stream.avg_frame_rate) ?? rate(stream.r_frame_rate) ?? 30,
+        duration: Number(stream.duration ?? data.format?.duration ?? 0),
+        transfer: stream.color_transfer ?? "",
+    };
+}
+/** The sound as 16 kHz mono samples between -1 and 1, what the speech model takes. */
+export async function audioSamples(path) {
+    const raw = await run("ffmpeg", [
+        "-v",
+        "error",
+        "-i",
+        path,
+        "-vn",
+        "-ac",
+        "1",
+        "-ar",
+        "16000",
+        "-f",
+        "f32le",
+        "pipe:1",
+    ]);
+    return new Float32Array(raw.buffer, raw.byteOffset, Math.floor(raw.byteLength / 4));
+}
+/** Runs FFmpeg with `args`, writing what `frames` gives to its input. */
+export async function encode(args, frames) {
+    await run("ffmpeg", args, frames);
+}

package/dist/local/transcribe.js

@@ -0,0 +1,260 @@
+/**
+ * Transcription on this computer: Parakeet Ultra, the server's own default model and the same
+ * pinned files, run by sherpa-onnx. The audio is cut into windows and the model's pieces made into
+ * timed words exactly as the server does it (`apps/api/app/transcription/chunking.py` and
+ * `sherpa.py`); the Swift app has its own copy too, and all three pass the shared
+ * `Fixtures/token-words.json`.
+ */
+import { createWriteStream } from "node:fs";
+import { mkdir, rename, rm, stat } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { availableParallelism } from "node:os";
+import { join } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { OpenCaptionsError } from "../client.js";
+import { cacheDir } from "./cache.js";
+import { audioSamples } from "./media.js";
+const SAMPLE_RATE = 16_000;
+/** Loudness is judged on 50 ms frames. */
+const FRAME = SAMPLE_RATE / 20;
+/** The part of a window, from its start, in which the cut is looked for. */
+const CUT_FROM = 0.6;
+/** Below this mean level (dBFS) a window is silence for the retry's purposes. */
+const QUIET_DB = -55;
+/** The shortest piece an empty window is split into. */
+const MIN_RETRY_S = 4;
+const WINDOW_S = 20;
+const SENTENCE_END = [".", "?", "!", "…", "。", "？", "！"];
+/** The model, as `apps/api/app/services/asr_models.py` pins it. */
+const MODEL = {
+    id: "parakeet-ultra",
+    repo: "leogaudin/sherpa-onnx-nemo-parakeet-ultra-int8",
+    revision: "f7bc472677ff70be95cdb0ef9df509fee6f5ec0b",
+    files: ["encoder.int8.onnx", "decoder.int8.onnx", "joiner.int8.onnx", "tokens.txt"],
+    languages: new Set("bg hr cs da nl en et fi fr de el hu it lv lt mt pl pt ro ru sk sl es sv uk".split(" ")),
+};
+/**
+ * SentencePiece pieces grouped into timed words: a leading space (or ▁) starts a word, and so does
+ * a piece of nothing but that mark; empty and special pieces (`<blank>`) are skipped. A word's
+ * confidence is the geometric mean of its pieces' probabilities.
+ */
+export function wordsFromTokens(tokens, starts, durations, logProbs) {
+    const words = [];
+    let boundary = true;
+    tokens.forEach((token, index) => {
+        const piece = token.replaceAll("▁", " ");
+        const text = piece.trim();
+        if (!text || (text.startsWith("<") && text.endsWith(">"))) {
+            boundary ||= piece.startsWith(" ");
+            return;
+        }
+        const start = starts[index] ?? 0;
+        const end = start + (durations[index] ?? 0);
+        const logProb = logProbs[index] ?? 0;
+        const last = words.at(-1);
+        if (boundary || piece.startsWith(" ") || !last) {
+            words.push({ text, start, end, probs: [logProb] });
+            boundary = false;
+        }
+        else {
+            last.text += text;
+            last.end = end;
+            last.probs.push(logProb);
+        }
+    });
+    return words.map(({ text, start, end, probs }) => {
+        const from = Math.max(0, start);
+        const confidence = Math.exp(probs.reduce((a, b) => a + b, 0) / probs.length);
+        return [text, from, Math.max(end, from), Math.min(1, Math.max(0, confidence))];
+    });
+}
+/** Every word ends before the next one starts (windows can overlap by a piece). */
+export function separate(words) {
+    for (let i = 0; i + 1 < words.length; i++) {
+        const [word, next] = [words[i], words[i + 1]];
+        if (word[2] > next[1])
+            word[2] = Math.max(word[1], next[1]);
+    }
+}
+/** The level of every 50 ms frame, in dBFS. */
+function frameLevels(samples) {
+    const levels = new Float64Array(Math.floor(samples.length / FRAME));
+    for (let f = 0; f < levels.length; f++) {
+        let sum = 0;
+        for (let i = f * FRAME; i < (f + 1) * FRAME; i++)
+            sum += (samples[i] ?? 0) ** 2;
+        levels[f] = 10 * Math.log10(sum / FRAME + 1e-12);
+    }
+    return levels;
+}
+/** The frame in [first, last) with the lowest level; the latest one if several tie. */
+function quietestCut(levels, first, last) {
+    let best = first;
+    for (let f = first; f < last; f++)
+        if ((levels[f] ?? 0) <= (levels[best] ?? 0))
+            best = f;
+    return best;
+}
+/** Consecutive [start, end) sample ranges covering the audio, none longer than `maxS`. */
+export function windows(samples, maxS) {
+    const longest = Math.floor((maxS * SAMPLE_RATE) / FRAME);
+    const levels = frameLevels(samples);
+    const out = [];
+    let start = 0;
+    while (start < samples.length) {
+        const endFrame = Math.floor(start / FRAME) + longest;
+        if (endFrame * FRAME >= samples.length) {
+            out.push([start, samples.length]);
+            break;
+        }
+        const first = Math.floor(start / FRAME) + Math.max(1, Math.floor(longest * CUT_FROM));
+        const cut = quietestCut(levels, first, endFrame) * FRAME;
+        out.push([start, cut]);
+        start = cut;
+    }
+    return out;
+}
+function isQuiet(samples) {
+    const levels = frameLevels(samples);
+    return levels.length === 0 || levels.reduce((a, b) => a + b, 0) / levels.length < QUIET_DB;
+}
+/**
+ * Words for a window, timed from the start of the audio. A window that yields nothing though it
+ * is not quiet is split at its quietest point near the middle and each half decoded alone.
+ */
+export function decodeWindow(decode, samples, offset) {
+    const words = decode(samples).map(([text, start, end, confidence]) => [text, offset + start, offset + end, confidence]);
+    if (words.length || samples.length < 2 * MIN_RETRY_S * SAMPLE_RATE || isQuiet(samples)) {
+        return words;
+    }
+    const levels = frameLevels(samples);
+    const middle = Math.floor(levels.length / 2);
+    const spread = Math.max(1, Math.floor(levels.length / 5));
+    const cut = quietestCut(levels, middle - spread, middle + spread) * FRAME;
+    return [
+        ...decodeWindow(decode, samples.subarray(0, cut), offset),
+        ...decodeWindow(decode, samples.subarray(cut), offset + cut / SAMPLE_RATE),
+    ];
+}
+/** Segments that end at a sentence's end; the rest of the words form the last one. */
+export function segments(words) {
+    const out = [];
+    let current = [];
+    const close = () => {
+        const first = current[0];
+        const last = current.at(-1);
+        if (!first || !last)
+            return;
+        out.push({
+            id: crypto.randomUUID(),
+            start: first[1],
+            end: last[2],
+            text: current.map((w) => w[0]).join(" "),
+            words: current.map(([text, start, end, confidence]) => ({ text, start, end, confidence })),
+        });
+        current = [];
+    };
+    for (const word of words) {
+        current.push(word);
+        if (SENTENCE_END.some((mark) => word[0].endsWith(mark)))
+            close();
+    }
+    close();
+    return out;
+}
+/** The model's files in the cache, fetched once with progress. Returns the folder. */
+async function modelFolder(progress) {
+    const folder = join(cacheDir(), "models", MODEL.id, MODEL.revision);
+    await mkdir(folder, { recursive: true });
+    for (const [i, file] of MODEL.files.entries()) {
+        const path = join(folder, file);
+        if (await stat(path).catch(() => undefined))
+            continue;
+        const url = `https://huggingface.co/${MODEL.repo}/resolve/${MODEL.revision}/${file}`;
+        const response = await fetch(url);
+        if (!response.ok || !response.body) {
+            throw new OpenCaptionsError(`Could not download the speech model (${response.status}).`);
+        }
+        const size = Number(response.headers.get("content-length")) || 0;
+        let got = 0;
+        const counted = Readable.fromWeb(response.body);
+        counted.on("data", (chunk) => {
+            got += chunk.length;
+            if (size) {
+                progress((i + got / size) / MODEL.files.length, `Downloading the speech model, once (${Math.round(got / 1e6)} of ${Math.round(size / 1e6)} MB)`);
+            }
+        });
+        try {
+            await pipeline(counted, createWriteStream(`${path}.part`));
+            await rename(`${path}.part`, path);
+        }
+        catch (error) {
+            await rm(`${path}.part`, { force: true });
+            throw error;
+        }
+    }
+    return folder;
+}
+function recognizer(folder) {
+    let sherpa;
+    try {
+        sherpa = createRequire(import.meta.url)("sherpa-onnx-node");
+    }
+    catch (error) {
+        const why = String(error instanceof Error ? error.message : error).split("\n")[0];
+        throw new OpenCaptionsError(`sherpa-onnx, which runs the speech model, could not be loaded (${why}). Reinstall the ` +
+            "package, or set OPENCAPTIONS_URL and OPENCAPTIONS_KEY to transcribe on an OpenCaptions server.");
+    }
+    return new sherpa.OfflineRecognizer({
+        featConfig: { sampleRate: SAMPLE_RATE, featureDim: 80 },
+        modelConfig: {
+            transducer: {
+                encoder: join(folder, "encoder.int8.onnx"),
+                decoder: join(folder, "decoder.int8.onnx"),
+                joiner: join(folder, "joiner.int8.onnx"),
+            },
+            tokens: join(folder, "tokens.txt"),
+            modelType: "nemo_transducer",
+            numThreads: availableParallelism(),
+        },
+    });
+}
+export async function transcribe(source, request, progress) {
+    if (request.model && request.model !== MODEL.id) {
+        throw new OpenCaptionsError(`Without a server, the speech model is ${MODEL.id}. For ${request.model}, set ` +
+            "OPENCAPTIONS_URL and OPENCAPTIONS_KEY to use an OpenCaptions server.");
+    }
+    const language = request.language ?? "auto";
+    if (language !== "auto" && !MODEL.languages.has(language)) {
+        throw new OpenCaptionsError(`${MODEL.id} does not transcribe ${language}: it covers 25 European languages. Use an ` +
+            "OpenCaptions server with a Whisper model for this one.");
+    }
+    const folder = await modelFolder(progress);
+    progress(0, "Reading the sound");
+    const samples = await audioSamples(source);
+    const model = recognizer(folder);
+    const decode = (window) => {
+        const stream = model.createStream();
+        stream.acceptWaveform({ sampleRate: SAMPLE_RATE, samples: window });
+        model.decode(stream);
+        const r = model.getResult(stream);
+        return wordsFromTokens(r.tokens, r.timestamps, r.durations, r.ys_log_probs);
+    };
+    const duration = samples.length / SAMPLE_RATE;
+    const words = [];
+    for (const [start, end] of windows(samples, WINDOW_S)) {
+        for (const word of decodeWindow(decode, samples.subarray(start, end), start / SAMPLE_RATE)) {
+            words.push([word[0], word[1], Math.min(word[2], duration), word[3]]);
+        }
+        progress(end / samples.length, `Transcribed ${(end / SAMPLE_RATE).toFixed(1)}s of ${duration.toFixed(1)}s`);
+    }
+    separate(words);
+    return {
+        schema_version: 1,
+        language: language === "auto" ? "en" : language,
+        language_detection: language === "auto" ? "auto" : "manual",
+        duration,
+        segments: segments(words),
+    };
+}

package/dist/mcp.js

@@ -6,8 +6,8 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { captionVideo, defaultOutput, exportSubtitles, fixWords, getProject, readTranscript, resume, saveVideo, setStyle, } from "./captions.js";
-import { api, connectionFromEnv, OpenCaptionsError } from "./client.js";
+import { captionerFromEnv } from "./captioner.js";
+import { OpenCaptionsError } from "./client.js";
 import { describeLook, describeStyle, LOOKS, SAVE_SCHEMA, STYLE_SCHEMA } from "./looks.js";
 import { VERSION } from "./version.js";
 /** How long a tool waits for the server before handing back a ticket, in seconds. */
@@ -26,7 +26,10 @@ const saveProperties = {
         description: "Where to write the file. Default: next to the source, named <name>.captioned",
     },
 };
-const project = { type: "string", description: "The project id a caption_video call returned" };
+const project = {
+    type: "string",
+    description: "The project id a caption_video call returned (on this computer, a file's path)",
+};
 const TOOLS = [
     {
         name: "caption_video",
@@ -52,7 +55,8 @@ const TOOLS = [
                 language: { type: "string", description: "ISO 639-1 code, or auto (the default)" },
                 model: {
                     type: "string",
-                    description: "A speech model id the server offers; its default if left out",
+                    description: "A speech model id the server offers; its default if left out. Without a server, " +
+                        "parakeet-ultra only",
                 },
                 ...saveProperties,
             },
@@ -171,45 +175,40 @@ function saveArgs(args) {
         output: args.output,
     };
 }
-async function call(client, name, args, progress) {
+async function call(captioner, name, args, progress) {
     const deadline = Date.now() + WAIT_S * 1000;
     const id = args.project_id;
     switch (name) {
         case "caption_video":
-            return outcome(await captionVideo(client, { ...args, ...saveArgs(args) }, progress, deadline));
+            return outcome(await captioner.caption({ ...args, ...saveArgs(args) }, progress, deadline));
         case "check_progress":
-            return outcome(await resume(client, args.ticket, progress, deadline));
+            return outcome(await captioner.resume(args.ticket, progress, deadline));
         case "list_looks":
             return said(LOOKS.map(describeLook).join("\n"));
         case "describe_style":
             return said(describeStyle());
         case "get_transcript":
-            return said("Captions as shown, then each word with its index:", await readTranscript(client, id));
+            return said("Captions as shown, then each word with its index:", await captioner.readTranscript(id));
         case "fix_words":
-            return said(`Fixed ${await fixWords(client, id, args.fixes)} words. Call save_video to write the video again.`);
+            return said(`Fixed ${await captioner.fixWords(id, args.fixes)} words. Call save_video to write the video again.`);
         case "set_style": {
-            const style = await setStyle(client, id, args.look, args.style);
+            const style = await captioner.setStyle(id, args.look, args.style);
             return said("The style is set. Call save_video to write the video again.", style);
         }
-        case "save_video": {
-            const options = saveArgs(args);
-            const stem = defaultOutput((await getProject(client, id)).title, options.captions_only);
-            return outcome(await saveVideo(client, id, { ...options, stem }, progress, deadline));
-        }
-        case "export_subtitles": {
-            const kind = args.format;
-            const output = args.output ?? defaultOutput((await getProject(client, id)).title);
-            return said(`Wrote ${await exportSubtitles(client, id, kind, output)}`);
-        }
+        case "save_video":
+            return outcome(await captioner.save(id, saveArgs(args), progress, deadline));
+        case "export_subtitles":
+            return said(`Wrote ${await captioner.exportSubtitles(id, args.format, args.output)}`);
         default:
             throw new OpenCaptionsError(`There is no tool called ${name}.`);
     }
 }
-export function createServer(connect = () => api(connectionFromEnv())) {
+export function createServer(connect = captionerFromEnv) {
     const server = new Server({ name: "opencaptions", version: VERSION }, {
         capabilities: { tools: {} },
-        instructions: "OpenCaptions adds animated word-by-word captions to videos, on the user's own OpenCaptions " +
-            "server. caption_video does it in one call; the other tools adjust the result.",
+        instructions: "OpenCaptions adds animated word-by-word captions to videos, on this computer or on the " +
+            "user's own OpenCaptions server. caption_video does it in one call; the other tools " +
+            "adjust the result.",
     });
     server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
     server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
@@ -223,7 +222,7 @@ export function createServer(connect = () => api(connectionFromEnv())) {
             });
         };
         try {
-            return await call(connect(), request.params.name, request.params.arguments ?? {}, progress);
+            return await call(await connect(), request.params.name, request.params.arguments ?? {}, progress);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);