@xopcai/xopc 0.0.324 → 0.0.329

package/dist/src/voice/local/runtime-worker.js

@@ -1,271 +0,0 @@
-import { getLocalVoiceModel, resolveLocalVoiceModelDir } from "./models.js";
-import { downloadLocalVoiceModelFiles } from "./model-files.js";
-import { join, resolve, sep } from "node:path";
-import { mkdir, rm } from "node:fs/promises";
-import { EnvHttpProxyAgent, RetryAgent, setGlobalDispatcher } from "undici";
-import { createInterface } from "node:readline";
-//#region src/voice/local/runtime-worker.ts
-const pipelines = /* @__PURE__ */ new Map();
-const sherpaRecognizers = /* @__PURE__ */ new Map();
-async function assertLocalVoiceEngineAvailable(modelId) {
-	const model = getLocalVoiceModel(modelId);
-	if (model.engine === "sherpa-onnx") {
-		const imported = await import("sherpa-onnx-node").catch((cause) => {
-			throw new Error("The sherpa-onnx local voice engine is not installed. Install sherpa-onnx-node@1.13.4 alongside @xopcai/xopc.", { cause });
-		});
-		if (typeof (imported.default ?? imported).OfflineRecognizer !== "function") throw new Error("The sherpa-onnx local voice engine did not expose OfflineRecognizer");
-	} else await import("@huggingface/transformers").catch((cause) => {
-		throw new Error("The Transformers.js local voice engine is not installed. Install @huggingface/transformers@3.8.1 alongside @xopcai/xopc.", { cause });
-	});
-	return model.engine;
-}
-const networkAgent = new RetryAgent(new EnvHttpProxyAgent(), {
-	maxRetries: 4,
-	minTimeout: 500,
-	maxTimeout: 8e3,
-	timeoutFactor: 2,
-	retryAfter: true
-});
-setGlobalDispatcher(networkAgent);
-function normalizeRemoteHost(value) {
-	const url = new URL(value);
-	if (url.username || url.password) throw new Error("Local voice model endpoint must not contain credentials");
-	if (url.protocol !== "https:" && url.hostname !== "127.0.0.1" && url.hostname !== "localhost") throw new Error("Local voice model endpoint must use HTTPS");
-	url.pathname = `${url.pathname.replace(/\/+$/, "")}/`;
-	return url.toString();
-}
-function resolveRemoteHosts() {
-	const configured = process.env.XOPC_VOICE_MODEL_ENDPOINT?.trim() || process.env.HF_ENDPOINT?.trim();
-	if (configured) return [normalizeRemoteHost(configured)];
-	return [normalizeRemoteHost("https://xopc.ai/api/voice/models"), normalizeRemoteHost("https://huggingface.co")];
-}
-function serializeError(error) {
-	if (!(error instanceof Error)) return { message: String(error) };
-	const withCode = error;
-	const nested = withCode.cause;
-	const nestedMessage = nested instanceof Error ? nested.message : void 0;
-	const nestedCode = nested && typeof nested === "object" && "code" in nested ? String(nested.code ?? "") : void 0;
-	return {
-		message: error.message,
-		...typeof withCode.code === "string" ? { code: withCode.code } : {},
-		...nestedCode ? { code: nestedCode } : {},
-		...nestedMessage && nestedMessage !== error.message ? { cause: nestedMessage } : {}
-	};
-}
-function send(message) {
-	process.stdout.write(`${JSON.stringify(message)}\n`);
-}
-async function loadPipeline(modelId, allowRemote, cacheDir = resolveLocalVoiceModelDir(modelId), onProgress) {
-	const key = `${modelId}:${cacheDir}`;
-	const existing = pipelines.get(key);
-	if (existing) return existing;
-	const model = getLocalVoiceModel(modelId);
-	if (model.engine !== "transformers.js") throw new Error(`Model ${model.id} does not use the Transformers.js engine`);
-	const promise = (async () => {
-		let transformers;
-		try {
-			transformers = await import("@huggingface/transformers");
-		} catch (cause) {
-			throw new Error("The Transformers.js local voice engine is not installed. Install @huggingface/transformers@3.8.1 alongside @xopcai/xopc; use npm install -g when xopc is installed globally.", { cause });
-		}
-		transformers.env.cacheDir = cacheDir;
-		transformers.env.allowRemoteModels = allowRemote;
-		transformers.env.allowLocalModels = true;
-		const remoteHosts = allowRemote ? resolveRemoteHosts() : [normalizeRemoteHost("https://xopc.ai")];
-		let lastError;
-		for (const [index, remoteHost] of remoteHosts.entries()) {
-			transformers.env.remoteHost = remoteHost;
-			try {
-				return await transformers.pipeline("automatic-speech-recognition", model.repository, {
-					revision: model.revision,
-					dtype: model.dtype,
-					progress_callback: onProgress
-				});
-			} catch (error) {
-				lastError = error;
-				if (index + 1 < remoteHosts.length) {
-					await rm(cacheDir, {
-						recursive: true,
-						force: true
-					});
-					await mkdir(cacheDir, { recursive: true });
-				}
-			}
-		}
-		throw lastError;
-	})();
-	pipelines.set(key, promise);
-	try {
-		return await promise;
-	} catch (error) {
-		pipelines.delete(key);
-		throw error;
-	}
-}
-function normalizeSenseVoiceLanguage(language) {
-	if (typeof language !== "string") return "auto";
-	const value = language.trim().toLowerCase().replace("_", "-");
-	if (!value || value === "auto") return "auto";
-	if (value === "cmn" || value.startsWith("zh")) return "zh";
-	if (value === "cantonese" || value.startsWith("yue")) return "yue";
-	if (value.startsWith("en")) return "en";
-	if (value.startsWith("ja")) return "ja";
-	if (value.startsWith("ko")) return "ko";
-	return "auto";
-}
-function cleanSenseVoiceTag(value) {
-	return value?.replace(/^<\|/, "").replace(/\|>$/, "").trim() || void 0;
-}
-async function loadSherpaRecognizer(modelId, language) {
-	const key = `${modelId}:${language}`;
-	const existing = sherpaRecognizers.get(key);
-	if (existing) return existing;
-	const model = getLocalVoiceModel(modelId);
-	if (model.engine !== "sherpa-onnx") throw new Error(`Model ${model.id} does not use the sherpa-onnx engine`);
-	const modelDir = resolveLocalVoiceModelDir(model.id);
-	const promise = (async () => {
-		let imported;
-		try {
-			imported = await import("sherpa-onnx-node");
-		} catch (cause) {
-			throw new Error("The sherpa-onnx local voice engine is not installed. Install sherpa-onnx-node@1.13.4 alongside @xopcai/xopc; use npm install -g when xopc is installed globally.", { cause });
-		}
-		return new (imported.default ?? imported).OfflineRecognizer({
-			featConfig: {
-				sampleRate: 16e3,
-				featureDim: 80
-			},
-			modelConfig: {
-				senseVoice: {
-					model: join(modelDir, "model.int8.onnx"),
-					language,
-					useInverseTextNormalization: 1
-				},
-				tokens: join(modelDir, "tokens.txt"),
-				numThreads: Math.max(1, Math.min(4, Number(process.env.XOPC_VOICE_THREADS) || 2)),
-				provider: "cpu",
-				debug: 0
-			}
-		});
-	})();
-	sherpaRecognizers.set(key, promise);
-	try {
-		return await promise;
-	} catch (error) {
-		sherpaRecognizers.delete(key);
-		throw error;
-	}
-}
-async function transcribeWithSherpa(modelId, audio, language) {
-	const recognizer = await loadSherpaRecognizer(modelId, normalizeSenseVoiceLanguage(language));
-	const stream = recognizer.createStream();
-	stream.acceptWaveform({
-		sampleRate: 16e3,
-		samples: audio
-	});
-	const result = recognizer.decodeAsync ? await recognizer.decodeAsync(stream) : (recognizer.decode(stream), recognizer.getResult(stream));
-	return {
-		text: String(result.text ?? "").trim(),
-		...cleanSenseVoiceTag(result.lang) ? { language: cleanSenseVoiceTag(result.lang) } : {},
-		...cleanSenseVoiceTag(result.emotion) ? { emotion: cleanSenseVoiceTag(result.emotion) } : {},
-		...cleanSenseVoiceTag(result.event) ? { event: cleanSenseVoiceTag(result.event) } : {}
-	};
-}
-async function handle(request) {
-	const params = request.params ?? {};
-	if (request.method === "health") {
-		const modelId = typeof params.modelId === "string" && params.modelId ? params.modelId : void 0;
-		const selectedEngine = modelId ? await assertLocalVoiceEngineAvailable(modelId) : void 0;
-		return {
-			ok: true,
-			protocolVersion: 2,
-			engine: "transformers.js+sherpa-onnx",
-			engines: ["transformers.js", "sherpa-onnx"],
-			...modelId ? {
-				modelId,
-				selectedEngine
-			} : {}
-		};
-	}
-	if (request.method === "model.install") {
-		const modelId = String(params.modelId ?? "");
-		const modelDir = resolve(resolveLocalVoiceModelDir(modelId));
-		const requestedCacheDir = typeof params.cacheDir === "string" ? resolve(params.cacheDir) : modelDir;
-		const allowedPrefix = `${resolve(modelDir, "..")}${sep}`;
-		if (requestedCacheDir !== modelDir && !requestedCacheDir.startsWith(allowedPrefix)) throw new Error("Local voice model cache directory is outside the managed root");
-		const model = getLocalVoiceModel(modelId);
-		if (model.engine === "sherpa-onnx") await downloadLocalVoiceModelFiles({
-			model,
-			destinationDir: requestedCacheDir,
-			remoteHosts: resolveRemoteHosts(),
-			onProgress: (data) => send({
-				id: request.id,
-				event: "progress",
-				data
-			})
-		});
-		else {
-			await loadPipeline(modelId, true, requestedCacheDir, (data) => send({
-				id: request.id,
-				event: "progress",
-				data
-			}));
-			pipelines.delete(`${modelId}:${requestedCacheDir}`);
-		}
-		return {
-			installed: true,
-			modelId
-		};
-	}
-	if (request.method === "model.unload") {
-		const modelId = String(params.modelId ?? "");
-		for (const key of pipelines.keys()) if (key.startsWith(`${modelId}:`)) pipelines.delete(key);
-		for (const key of sherpaRecognizers.keys()) if (key.startsWith(`${modelId}:`)) sherpaRecognizers.delete(key);
-		return { unloaded: true };
-	}
-	if (request.method === "transcribe") {
-		const modelId = String(params.modelId ?? "");
-		const bytes = Buffer.from(String(params.audioBase64 ?? ""), "base64");
-		const copied = Uint8Array.from(bytes);
-		const audio = new Float32Array(copied.buffer);
-		const language = typeof params.language === "string" && params.language ? params.language : void 0;
-		const model = getLocalVoiceModel(modelId);
-		if (model.engine === "sherpa-onnx") return {
-			...await transcribeWithSherpa(model.id, audio, language),
-			modelId
-		};
-		const output = await (await loadPipeline(modelId, false))(audio, {
-			task: "transcribe",
-			...language ? { language } : {},
-			chunk_length_s: 30,
-			stride_length_s: 5,
-			return_timestamps: false
-		});
-		return {
-			text: (output && typeof output === "object" && "text" in output ? String(output.text ?? "") : "").trim(),
-			modelId
-		};
-	}
-	throw new Error(`Unknown local voice runtime method: ${request.method}`);
-}
-const lines = createInterface({ input: process.stdin });
-lines.on("line", (line) => {
-	let request;
-	try {
-		request = JSON.parse(line);
-	} catch {
-		return;
-	}
-	handle(request).then((result) => send({
-		id: request.id,
-		result
-	}), (error) => send({
-		id: request.id,
-		error: serializeError(error)
-	}));
-});
-lines.once("close", () => {
-	networkAgent.close().finally(() => process.exit(0));
-});
-//#endregion
-export {};

package/dist/src/voice/stt/providers/local-transcription.d.ts

@@ -1,2 +0,0 @@
-import type { MediaUnderstandingProvider } from '../../../media-understanding/types.js';
-export declare const localTranscriptionProvider: MediaUnderstandingProvider;

package/dist/src/voice/stt/providers/local-transcription.js

@@ -1,53 +0,0 @@
-import { createLogger } from "../../../utils/logger/index.js";
-import { init_logger } from "../../../utils/logger.js";
-import { DEFAULT_LOCAL_VOICE_MODEL_ID, getLocalVoiceModel, hasInstalledLocalVoiceModel, isLocalVoiceModelInstalled } from "../../local/models.js";
-import { registerMediaUnderstandingProvider } from "../../../media-understanding/registry.js";
-import { getLocalVoiceRuntimeClient } from "../../local/runtime-client.js";
-import { decodeAudioToMonoFloat32 } from "../../audio/normalize.js";
-//#region src/voice/stt/providers/local-transcription.ts
-init_logger();
-const log = createLogger("STT:Local");
-async function transcribeAudio(req) {
-	const model = getLocalVoiceModel(req.model);
-	if (!isLocalVoiceModelInstalled(model.id)) throw new Error(`Local voice model "${model.id}" is not installed`);
-	const decoded = await decodeAudioToMonoFloat32({
-		buffer: req.buffer,
-		signal: req.signal
-	});
-	const audioBytes = Buffer.from(decoded.samples.buffer, decoded.samples.byteOffset, decoded.samples.byteLength);
-	const startedAt = Date.now();
-	const result = await getLocalVoiceRuntimeClient().request("transcribe", {
-		modelId: model.id,
-		audioBase64: audioBytes.toString("base64"),
-		...req.language ? { language: req.language } : {}
-	}, {
-		signal: req.signal,
-		timeoutMs: req.timeoutMs
-	});
-	log.info({
-		model: model.id,
-		audioDurationSeconds: decoded.durationSeconds,
-		latencyMs: Date.now() - startedAt,
-		realTimeFactor: decoded.durationSeconds > 0 ? (Date.now() - startedAt) / 1e3 / decoded.durationSeconds : void 0,
-		textLength: result.text.length
-	}, "Local transcription completed");
-	return {
-		text: result.text,
-		model: model.id,
-		...result.language || req.language ? { language: result.language ?? req.language } : {},
-		durationSeconds: decoded.durationSeconds
-	};
-}
-const localTranscriptionProvider = {
-	id: "xopc-local",
-	aliases: ["local"],
-	capabilities: ["audio"],
-	requiresApiKey: false,
-	defaultModels: { audio: DEFAULT_LOCAL_VOICE_MODEL_ID },
-	autoPriority: { audio: 0 },
-	isConfigured: (options) => options?.model ? isLocalVoiceModelInstalled(options.model) : hasInstalledLocalVoiceModel(),
-	transcribeAudio
-};
-registerMediaUnderstandingProvider(localTranscriptionProvider);
-//#endregion
-export { localTranscriptionProvider };