@openspecui/server 3.9.0 → 3.10.0

package/dist/index.mjs

@@ -6616,12 +6616,12 @@ var TranslationEngineService = class {
 	}
 	async loadFactory(engineId, model) {
 		const globalSettings = await this.globalSettingsManager.readSettings();
-		if (engineId === "local") return (await import("@openspecui/local-translator")).createLocalTranslatorFactory({
+		if (engineId === "local") return (await import("./src-DBFY1eQK.mjs")).createLocalTranslatorFactory({
 			defaultModel: model ?? globalSettings.translationEngines.local.model,
 			cacheDir: this.localCacheDir,
 			localOnly: true
 		});
-		return (await import("@openspecui/openai-completion-translator")).createOpenAICompletionTranslatorFactory({
+		return (await import("./src-DuQ_-3Kn.mjs")).createOpenAICompletionTranslatorFactory({
 			baseUrl: globalSettings.translationEngines.openai.baseUrl,
 			token: globalSettings.translationEngines.openai.token,
 			model: model ?? globalSettings.translationEngines.openai.model

package/dist/src-DBFY1eQK.mjs

@@ -0,0 +1,121 @@
+import { join } from "node:path";
+import { readFile } from "node:fs/promises";
+import "@openspecui/core/local-download-profiles";
+
+//#region ../local-translator/src/index.ts
+const DEFAULT_MODEL = "Xenova/nllb-200-distilled-600M";
+var LocalTranslatorFactory = class {
+	constructor(options = {}) {
+		this.options = options;
+	}
+	async prepare(options) {
+		await (await loadTranslationPipeline(options.model || this.options.defaultModel || DEFAULT_MODEL, options.monitor, this.options.cacheDir, options.dtype ?? this.options.dtype, this.options.localOnly, options.runtimeConfig)).dispose?.();
+	}
+	async create(options) {
+		return new LocalTranslator(await loadTranslationPipeline(options.model || this.options.defaultModel || DEFAULT_MODEL, options.monitor, this.options.cacheDir, options.dtype ?? this.options.dtype, this.options.localOnly, options.runtimeConfig), {
+			sourceLanguage: options.sourceLanguage,
+			targetLanguage: options.targetLanguage
+		});
+	}
+};
+function createLocalTranslatorFactory(options = {}) {
+	return new LocalTranslatorFactory(options);
+}
+var LocalTranslator = class {
+	constructor(pipeline, languages) {
+		this.pipeline = pipeline;
+		this.languages = languages;
+	}
+	async *batchTranslate(inputs, options) {
+		for (const [index, input] of inputs.entries()) {
+			throwIfAborted(options?.signal);
+			const result = await this.pipeline(input, {
+				src_lang: this.languages.sourceLanguage,
+				tgt_lang: this.languages.targetLanguage
+			});
+			throwIfAborted(options?.signal);
+			yield {
+				index,
+				output: readTranslatedText(result)
+			};
+		}
+	}
+	destroy() {
+		this.pipeline.dispose?.();
+	}
+};
+async function loadTranslationPipeline(model, monitor, cacheDir, dtype, localOnly = false, runtimeConfig) {
+	monitor?.setStatus({ message: `Loading local model ${model}.` });
+	const transformers = await import("@huggingface/transformers");
+	if (cacheDir && transformers.env) {
+		transformers.env.cacheDir = cacheDir;
+		transformers.env.localModelPath = join(cacheDir, "models");
+	}
+	if (transformers.env) {
+		transformers.env.allowLocalModels = true;
+		transformers.env.allowRemoteModels = !localOnly;
+	}
+	const runtimeModel = localOnly && cacheDir ? join(cacheDir, "models", model) : model;
+	const progressCallback = monitor ? (event) => {
+		const progress = readProgress(event);
+		monitor.setStatus({
+			message: progress === void 0 ? `Downloading local model ${model}.` : `Downloading local model ${model} ${Math.round(progress * 100)}%.`,
+			...progress === void 0 ? {} : { progress }
+		});
+	} : void 0;
+	const pipeline = await transformers.pipeline("translation", runtimeModel, {
+		config: runtimeConfig ?? await readLocalRuntimeConfig({
+			cacheDir,
+			model,
+			localOnly
+		}),
+		...dtype ? { dtype } : {},
+		...localOnly ? { local_files_only: true } : {},
+		...progressCallback ? { progress_callback: progressCallback } : {}
+	});
+	monitor?.setStatus({
+		message: `Local model ${model} is ready.`,
+		progress: 1
+	});
+	return pipeline;
+}
+async function readLocalRuntimeConfig(input) {
+	if (!input.localOnly || !input.cacheDir) return void 0;
+	const configPath = join(input.cacheDir, "models", input.model, "config.json");
+	try {
+		return JSON.parse(await readFile(configPath, "utf8"));
+	} catch {
+		return;
+	}
+}
+function readTranslatedText(value) {
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) {
+		const first = value[0];
+		if (first && typeof first === "object") {
+			const text = first.translation_text;
+			if (typeof text === "string") return text;
+			const generated = first.generated_text;
+			if (typeof generated === "string") return generated;
+		}
+	}
+	if (value && typeof value === "object") {
+		const text = value.translation_text;
+		if (typeof text === "string") return text;
+		const generated = value.generated_text;
+		if (typeof generated === "string") return generated;
+	}
+	return String(value);
+}
+function readProgress(event) {
+	if (!event || typeof event !== "object") return void 0;
+	const record = event;
+	if (typeof record.progress === "number") return Math.max(0, Math.min(1, record.progress / (record.progress > 1 ? 100 : 1)));
+	if (typeof record.loaded === "number" && typeof record.total === "number" && record.total > 0) return Math.max(0, Math.min(1, record.loaded / record.total));
+}
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw new DOMException("The operation was aborted.", "AbortError");
+}
+
+//#endregion
+export { createLocalTranslatorFactory };