207 lines
10 KiB
JavaScript
207 lines
10 KiB
JavaScript
const { EventEmitter } = require("events");
|
|
const { spawn } = require("child_process");
|
|
const { BoundedQueue } = require("../sessions/bounded_queue");
|
|
|
|
class TranscriptionProvider extends EventEmitter {
|
|
async loadModel() { throw new Error("Model loading is not implemented."); }
|
|
async benchmark() { throw new Error("Benchmarking is not implemented."); }
|
|
async startSession() { throw new Error("Session start is not implemented."); }
|
|
async addTrack() { throw new Error("Track add is not implemented."); }
|
|
async pushAudio() { throw new Error("Audio input is not implemented."); }
|
|
async removeTrack() { throw new Error("Track removal is not implemented."); }
|
|
async stopSession() { throw new Error("Session stop is not implemented."); }
|
|
async health() { return { healthy: false, state: "unavailable" }; }
|
|
}
|
|
|
|
class WhisperWorkerSupervisor extends EventEmitter {
|
|
constructor(options = {}) {
|
|
super();
|
|
this.executable = options.executable;
|
|
this.args = options.args || [];
|
|
this.spawn = options.spawn || spawn;
|
|
this.maxRestarts = options.maxRestarts ?? 3;
|
|
this.restartWindowMs = options.restartWindowMs || 60000;
|
|
this.queue = new BoundedQueue({ maxItems: options.maxQueuedPackets || 250, maxBytes: options.maxQueuedBytes || 5 * 32000, maxAgeMs: 5000 });
|
|
this.child = null;
|
|
this.state = "stopped";
|
|
this.stopping = false;
|
|
this.restartTimes = [];
|
|
this.stdoutBuffer = "";
|
|
this.lastExit = null;
|
|
this.lastError = null;
|
|
this.lastDiagnostic = null;
|
|
this.startedAt = null;
|
|
}
|
|
start() {
|
|
if (this.child) return;
|
|
if (!this.executable) throw coded("WORKER_NOT_CONFIGURED", "The whisper.cpp worker is not installed. Build or install the Lumi transcription runtime, then retry.");
|
|
this.stopping = false;
|
|
this.state = "starting";
|
|
const child = this.spawn(this.executable, this.args, { stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
|
|
this.child = child;
|
|
this.startedAt = Date.now();
|
|
child.stdout.on("data", (chunk) => this.onStdout(chunk));
|
|
child.stderr.on("data", (chunk) => this.onDiagnostic(String(chunk).trim().slice(0, 1000)));
|
|
child.stdin.on("error", (error) => this.onIoError("stdin", error));
|
|
child.stdout.on("error", (error) => this.onIoError("stdout", error));
|
|
child.stderr.on("error", (error) => this.onIoError("stderr", error));
|
|
child.on("error", (error) => this.onProcessError(error));
|
|
child.on("exit", (code, signal) => this.onExit(code, signal));
|
|
child.stdin.on("drain", () => this.flush());
|
|
this.state = "running";
|
|
this.emit("state", { state: this.state });
|
|
this.flush();
|
|
}
|
|
send(metadata, pcm = null) {
|
|
const body = Buffer.from(JSON.stringify(metadata), "utf8");
|
|
const audio = pcm ? Buffer.from(pcm) : Buffer.alloc(0);
|
|
if (body.length > 64 * 1024 || audio.length > 5 * 32000) throw new Error("Worker packet exceeds its limit.");
|
|
const header = Buffer.alloc(8);
|
|
header.writeUInt32LE(body.length, 0);
|
|
header.writeUInt32LE(audio.length, 4);
|
|
const packet = Buffer.concat([header, body, audio]);
|
|
const accepted = this.queue.push(packet, { bytes: packet.length, capturedAt: metadata.captured_at || Date.now() });
|
|
if (accepted) this.flush();
|
|
return accepted;
|
|
}
|
|
flush() {
|
|
if (!this.child || this.state !== "running") return;
|
|
let packet;
|
|
try {
|
|
while ((packet = this.queue.shift())) if (!this.child.stdin.write(packet)) break;
|
|
} catch (error) { this.onIoError("stdin", error); }
|
|
}
|
|
async stop() {
|
|
this.stopping = true;
|
|
this.queue.clear();
|
|
const child = this.child;
|
|
if (!child) { this.state = "stopped"; return; }
|
|
this.sendDirect({ type: "shutdown" });
|
|
await new Promise((resolve) => {
|
|
const timer = setTimeout(() => { child.kill(); resolve(); }, 2000);
|
|
child.once("exit", () => { clearTimeout(timer); resolve(); });
|
|
});
|
|
this.child = null;
|
|
this.state = "stopped";
|
|
}
|
|
sendDirect(metadata) { if (!this.child) return false; const body = Buffer.from(JSON.stringify(metadata)); const header = Buffer.alloc(8); header.writeUInt32LE(body.length, 0); return this.child.stdin.write(Buffer.concat([header, body])); }
|
|
onStdout(chunk) {
|
|
this.stdoutBuffer += String(chunk);
|
|
if (this.stdoutBuffer.length > 256 * 1024) this.stdoutBuffer = this.stdoutBuffer.slice(-64 * 1024);
|
|
let index;
|
|
while ((index = this.stdoutBuffer.indexOf("\n")) >= 0) {
|
|
const line = this.stdoutBuffer.slice(0, index).trim();
|
|
this.stdoutBuffer = this.stdoutBuffer.slice(index + 1);
|
|
if (!line) continue;
|
|
try { this.emit("message", JSON.parse(line)); }
|
|
catch { this.onDiagnostic("Whisper worker emitted malformed output."); }
|
|
}
|
|
}
|
|
onDiagnostic(message) {
|
|
if (!message) return;
|
|
this.lastDiagnostic = { message, at: Date.now() };
|
|
this.emit("diagnostic", { level: "warning", message });
|
|
}
|
|
onIoError(stream, error) {
|
|
if (this.stopping) return;
|
|
this.lastError = { stream, code: error.code || null, message: error.message, at: Date.now() };
|
|
this.emit("error", Object.assign(new Error(`Whisper worker ${stream} failed: ${error.message}`), { code: error.code, stream }));
|
|
}
|
|
onProcessError(error) {
|
|
this.lastError = { stream: "process", code: error.code || null, message: error.message, at: Date.now() };
|
|
this.emit("error", error);
|
|
}
|
|
onExit(code, signal) {
|
|
this.child = null;
|
|
this.lastExit = { code, signal: signal || null, at: Date.now() };
|
|
if (this.stopping) { this.state = "stopped"; return; }
|
|
this.state = "failed";
|
|
this.emit("state", { state: this.state });
|
|
this.emit("crash", { code, signal, at: this.lastExit.at });
|
|
const now = Date.now();
|
|
this.restartTimes = this.restartTimes.filter((time) => now - time < this.restartWindowMs);
|
|
if (this.restartTimes.length >= this.maxRestarts) return;
|
|
this.restartTimes.push(now);
|
|
setTimeout(() => { try { this.start(); } catch (error) { this.emit("error", error); } }, 250).unref?.();
|
|
}
|
|
health() {
|
|
return {
|
|
healthy: this.state === "running", state: this.state, queue: this.queue.metrics(),
|
|
restarts_in_window: this.restartTimes.length, started_at: this.startedAt,
|
|
last_exit: this.lastExit, last_error: this.lastError, last_diagnostic: this.lastDiagnostic
|
|
};
|
|
}
|
|
}
|
|
|
|
class WhisperCppServerProvider extends TranscriptionProvider {
|
|
constructor(supervisor) {
|
|
super(); this.worker = supervisor; this.model = null; this.desiredModel = null; this.modelReady = false; this.loading = false; this.recovering = false; this.sessions = new Set();
|
|
supervisor.on("message", (message) => this.emit(message.type || "message", message));
|
|
supervisor.on("crash", (event) => {
|
|
this.modelReady = false;
|
|
this.sessions.clear();
|
|
this.emit("provider_error", Object.assign(new Error(`Whisper worker exited unexpectedly${event.code == null ? "" : ` with code ${event.code}`}.`), { code: "WORKER_CRASHED", details: event }));
|
|
});
|
|
supervisor.on("error", (error) => this.emit("provider_error", error));
|
|
supervisor.on("state", ({ state }) => {
|
|
if (state === "running" && this.desiredModel && !this.modelReady && !this.loading && !this.recovering) this.recoverModel();
|
|
});
|
|
}
|
|
async loadModel(model) {
|
|
this.desiredModel = model;
|
|
this.loading = true;
|
|
try {
|
|
this.worker.start();
|
|
const result = await this.requestModel(model);
|
|
this.model = model;
|
|
this.modelReady = true;
|
|
return { ...(await this.health()), loaded: result };
|
|
} finally { this.loading = false; }
|
|
}
|
|
async requestModel(model) {
|
|
const loaded = new Promise((resolve, reject) => {
|
|
const timer = setTimeout(() => { cleanup(); reject(new Error("The whisper.cpp worker did not confirm model loading in time.")); }, 30000);
|
|
const onLoaded = (event) => { cleanup(); resolve(event); };
|
|
const onError = (event) => { cleanup(); reject(Object.assign(new Error(event.message || "The model could not be loaded."), { code: event.code })); };
|
|
const onProviderError = (error) => { cleanup(); reject(error); };
|
|
const cleanup = () => { clearTimeout(timer); this.off("model_loaded", onLoaded); this.off("model_error", onError); this.off("provider_error", onProviderError); };
|
|
this.once("model_loaded", onLoaded); this.once("model_error", onError);
|
|
this.once("provider_error", onProviderError);
|
|
});
|
|
this.worker.send({ type: "load_model", model });
|
|
return loaded;
|
|
}
|
|
recoverModel() {
|
|
this.recovering = true;
|
|
this.requestModel(this.desiredModel).then((result) => {
|
|
this.model = this.desiredModel;
|
|
this.modelReady = true;
|
|
this.emit("recovered", { model_id: result.model_id || this.model?.id || null, backend: result.backend || null });
|
|
}).catch((error) => this.emit("provider_error", Object.assign(error, { code: error.code || "MODEL_RECOVERY_FAILED" })))
|
|
.finally(() => { this.recovering = false; });
|
|
}
|
|
async benchmark(options = {}) { this.worker.send({ type: "benchmark", options }); return { accepted: true, model: this.model?.id || null }; }
|
|
async startSession(session) {
|
|
if (!this.modelReady) throw coded("PROVIDER_UNAVAILABLE", "The speech model is not ready in the worker.");
|
|
this.sessions.add(session.id); this.worker.send({ type: "start_session", session });
|
|
}
|
|
async addTrack(sessionId, track) { this.worker.send({ type: "add_track", session_id: sessionId, track }); }
|
|
async pushAudio(sessionId, trackId, frame) { return this.worker.send({ type: "audio", session_id: sessionId, track_id: trackId, sequence: frame.sequence, capture_timestamp_us: frame.capture_timestamp_us, captured_at: Date.now() }, frame.pcm); }
|
|
async removeTrack(sessionId, trackId) { this.worker.send({ type: "remove_track", session_id: sessionId, track_id: trackId }); }
|
|
async stopSession(sessionId) { this.sessions.delete(sessionId); this.worker.send({ type: "stop_session", session_id: sessionId }); }
|
|
async health() {
|
|
const worker = this.worker.health();
|
|
return {
|
|
...worker, provider: "whisper_cpp_server", model: this.model?.id || this.desiredModel?.id || null,
|
|
model_ready: this.modelReady, sessions: this.sessions.size,
|
|
healthy: worker.healthy && this.modelReady,
|
|
state: !worker.healthy ? worker.state : this.modelReady ? "running" : this.recovering || this.loading ? "loading_model" : "model_unavailable"
|
|
};
|
|
}
|
|
async stop() { this.sessions.clear(); this.modelReady = false; await this.worker.stop(); }
|
|
}
|
|
|
|
function coded(code, message) { return Object.assign(new Error(message), { code }); }
|
|
|
|
module.exports = { TranscriptionProvider, WhisperWorkerSupervisor, WhisperCppServerProvider };
|