@openspecui/server 3.11.1 → 3.11.3

package/dist/src-8bHfOTUF.mjs

@@ -0,0 +1,3 @@
+import { a as resolveCt2ModelDownloadPlanFromRepositoryFiles, i as CT2_REQUIRED_FILE_NAMES, n as createLocalCt2TranslatorFactory, r as CT2_OPTIONAL_FILE_NAMES, t as LocalCt2TranslatorFactory } from "./src-BJ-K9Dp2.mjs";
+
+export { createLocalCt2TranslatorFactory };

package/dist/src-BJ-K9Dp2.mjs

@@ -0,0 +1,208 @@
+import { join, posix } from "node:path";
+
+//#region ../local-ct2-translator/src/ct2-download-plan.ts
+const CT2_REQUIRED_FILE_NAMES = [
+	"config.json",
+	"model.bin",
+	"shared_vocabulary.json",
+	"source.spm",
+	"target.spm"
+];
+const CT2_OPTIONAL_FILE_NAMES = ["tokenizer_config.json", "vocab.json"];
+const CT2_OPTIONAL_FILE_NAME_SET = new Set(CT2_OPTIONAL_FILE_NAMES);
+function resolveCt2ModelDownloadPlanFromRepositoryFiles(input) {
+	const normalizedFiles = dedupeFiles(input.files.filter((file) => file.path.trim().length > 0).map((file) => ({
+		...file,
+		path: normalizePath(file.path)
+	})));
+	const fileByPath = new Map(normalizedFiles.map((file) => [file.path, file]));
+	const groups = collectCandidateRoots(normalizedFiles).map((rootDir) => createGroup(rootDir, fileByPath)).filter((group) => group !== null);
+	if (groups.length === 0) return null;
+	return buildPlan(input.modelId, groups, input.selectedGroupId);
+}
+function collectCandidateRoots(files) {
+	const roots = /* @__PURE__ */ new Set();
+	for (const file of files) {
+		if (posix.basename(file.path) !== "model.bin") continue;
+		roots.add(normalizeDir(posix.dirname(file.path)));
+	}
+	return [...roots];
+}
+function createGroup(rootDir, fileByPath) {
+	const requiredFiles = CT2_REQUIRED_FILE_NAMES.map((fileName) => fileByPath.get(joinRootFile(rootDir, fileName)));
+	if (requiredFiles.some((file) => file === void 0)) return null;
+	const concreteRequiredFiles = requiredFiles.filter((file) => file !== void 0);
+	const optionalFiles = CT2_OPTIONAL_FILE_NAMES.flatMap((fileName) => {
+		const file = fileByPath.get(joinRootFile(rootDir, fileName));
+		return file ? [file] : [];
+	});
+	const files = [...concreteRequiredFiles, ...optionalFiles].map((file) => toPlanFile(file));
+	const estimatedTotalBytes = files.reduce((total, file) => total + (file.sizeBytes ?? 0), 0);
+	const hasRequiredSizes = files.filter((file) => file.required).every((file) => file.sizeBytes !== void 0 && file.sizeBytes > 0);
+	return {
+		id: rootDir || "default",
+		label: rootDir ? posix.basename(rootDir) : "default",
+		description: rootDir ? `CTranslate2 artifacts from ${rootDir}.` : "CTranslate2 artifacts from the repository root.",
+		estimatedTotalBytes: estimatedTotalBytes > 0 ? estimatedTotalBytes : void 0,
+		selectable: hasRequiredSizes,
+		selected: false,
+		files
+	};
+}
+function toPlanFile(file) {
+	const required = !CT2_OPTIONAL_FILE_NAME_SET.has(posix.basename(file.path));
+	return {
+		path: file.path,
+		sizeBytes: file.sizeBytes,
+		required,
+		etag: file.etag,
+		revision: file.revision,
+		sourceUrl: file.sourceUrl,
+		raw: file.raw
+	};
+}
+function buildPlan(modelId, groups, selectedGroupId) {
+	const selectedGroup = selectRequestedGroup(groups, selectedGroupId) ?? selectDefaultGroup(groups) ?? groups[0];
+	const selectedId = selectedGroup.id;
+	const normalizedGroups = groups.map((group) => ({
+		...group,
+		selected: group.id === selectedId,
+		files: [...group.files]
+	}));
+	return {
+		modelId,
+		estimatedTotalBytes: selectedGroup.estimatedTotalBytes,
+		files: [...selectedGroup.files],
+		selectedGroupId: selectedId,
+		groups: normalizedGroups
+	};
+}
+function selectRequestedGroup(groups, selectedGroupId) {
+	if (!selectedGroupId) return null;
+	return groups.find((group) => group.id === selectedGroupId) ?? null;
+}
+function selectDefaultGroup(groups) {
+	const selectableGroups = groups.filter((group) => group.selectable);
+	if (selectableGroups.length === 0) return null;
+	return [...selectableGroups].sort((left, right) => {
+		return (left.estimatedTotalBytes ?? Number.POSITIVE_INFINITY) - (right.estimatedTotalBytes ?? Number.POSITIVE_INFINITY) || left.id.localeCompare(right.id);
+	})[0] ?? null;
+}
+function joinRootFile(rootDir, fileName) {
+	return rootDir ? `${rootDir}/${fileName}` : fileName;
+}
+function normalizeDir(input) {
+	if (input === "." || input === "") return "";
+	return normalizePath(input);
+}
+function normalizePath(input) {
+	return input.replace(/^\.\/+/u, "").replace(/\/+/gu, "/");
+}
+function dedupeFiles(files) {
+	const deduped = /* @__PURE__ */ new Map();
+	for (const file of files) deduped.set(file.path, file);
+	return [...deduped.values()];
+}
+
+//#endregion
+//#region ../local-ct2-translator/src/factory.ts
+var LocalCt2TranslatorFactory = class {
+	constructor(options = {}) {
+		this.options = options;
+	}
+	async prepare(options) {
+		const model = options.model || this.options.defaultModel;
+		if (!model) throw new Error("A CT2 model id or runtime model path is required.");
+		const resolvedConfig = readRuntimeConfig(options.runtimeConfig);
+		const modelPath = resolveModelPath({
+			model,
+			cacheDir: this.options.cacheDir,
+			runtimeConfig: resolvedConfig
+		});
+		options.monitor?.setStatus({ message: `Loading CT2 model ${model}.` });
+		await createRuntimeTranslator(this.options, modelPath, resolvedConfig);
+		options.monitor?.setStatus({
+			message: `CT2 model ${model} is ready.`,
+			progress: 1
+		});
+	}
+	async create(options) {
+		const model = options.model || this.options.defaultModel;
+		if (!model) throw new Error("A CT2 model id or runtime model path is required.");
+		const resolvedConfig = readRuntimeConfig(options.runtimeConfig);
+		const modelPath = resolveModelPath({
+			model,
+			cacheDir: this.options.cacheDir,
+			runtimeConfig: resolvedConfig
+		});
+		options.monitor?.setStatus({ message: `Loading CT2 model ${model}.` });
+		const translator = await createRuntimeTranslator(this.options, modelPath, resolvedConfig);
+		options.monitor?.setStatus({
+			message: `CT2 model ${model} is ready.`,
+			progress: 1
+		});
+		return new LocalCt2Translator(translator, resolvedConfig, this.options);
+	}
+};
+function createLocalCt2TranslatorFactory(options = {}) {
+	return new LocalCt2TranslatorFactory(options);
+}
+var LocalCt2Translator = class {
+	constructor(translator, runtimeConfig, factoryOptions) {
+		this.translator = translator;
+		this.runtimeConfig = runtimeConfig;
+		this.factoryOptions = factoryOptions;
+	}
+	async *batchTranslate(inputs, options) {
+		throwIfAborted(options?.signal);
+		const result = await this.translator.translateBatch(inputs, {
+			beamSize: this.runtimeConfig.beamSize ?? this.factoryOptions.beamSize,
+			maxBatchSize: this.runtimeConfig.maxBatchSize ?? this.factoryOptions.maxBatchSize,
+			returnScores: false
+		});
+		throwIfAborted(options?.signal);
+		if (result.length !== inputs.length) throw new Error(`CT2 translator returned ${result.length} outputs for ${inputs.length} inputs.`);
+		for (const [index, entry] of result.entries()) yield {
+			index,
+			output: entry.text
+		};
+	}
+};
+async function createRuntimeTranslator(options, modelPath, runtimeConfig) {
+	return new (await ((options.loadModule ?? loadCt2RuntimeModule)())).Ct2Translator({
+		modelPath,
+		device: runtimeConfig.device ?? options.device,
+		threads: runtimeConfig.threads ?? options.threads
+	});
+}
+async function loadCt2RuntimeModule() {
+	return await import("ctranslate2");
+}
+function resolveModelPath(input) {
+	if (input.runtimeConfig.modelPath) return input.runtimeConfig.modelPath;
+	if (input.cacheDir) return join(input.cacheDir, "models", input.model);
+	return input.model;
+}
+function readRuntimeConfig(runtimeConfig) {
+	return {
+		modelPath: readString(runtimeConfig, "modelPath"),
+		device: readString(runtimeConfig, "device"),
+		threads: readNumber(runtimeConfig, "threads"),
+		beamSize: readNumber(runtimeConfig, "beamSize"),
+		maxBatchSize: readNumber(runtimeConfig, "maxBatchSize")
+	};
+}
+function readString(record, key) {
+	const value = record?.[key];
+	return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readNumber(record, key) {
+	const value = record?.[key];
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw new DOMException("The operation was aborted.", "AbortError");
+}
+
+//#endregion
+export { resolveCt2ModelDownloadPlanFromRepositoryFiles as a, CT2_REQUIRED_FILE_NAMES as i, createLocalCt2TranslatorFactory as n, CT2_OPTIONAL_FILE_NAMES as r, LocalCt2TranslatorFactory as t };

package/dist/src-Cc9NSywS.mjs

@@ -0,0 +1,3 @@
+import { n as LocalLlamaTranslatorFactory, r as createLocalLlamaTranslatorFactory, t as resolveGgufModelDownloadPlanFromRepositoryFiles } from "./src-awZ9aP1s.mjs";
+
+export { createLocalLlamaTranslatorFactory };

package/dist/src-awZ9aP1s.mjs

@@ -0,0 +1,232 @@
+import { join, posix } from "node:path";
+
+//#region ../local-llama-translator/src/factory.ts
+const DEFAULT_SYSTEM_PROMPT = "You are a translation engine. Return only the translated text, preserve Markdown structure, inline code, URLs, and file paths.";
+var LocalLlamaTranslatorFactory = class {
+	constructor(options = {}) {
+		this.options = options;
+	}
+	async prepare(options) {
+		const model = options.model || this.options.defaultModel;
+		if (!model) throw new Error("A GGUF model id or runtime model path is required.");
+		const module = await (this.options.loadModule ?? loadLlamaRuntimeModule)();
+		const resolvedConfig = readRuntimeConfig(options.runtimeConfig);
+		const runtimeModel = await loadRuntimeModel({
+			module,
+			model,
+			cacheDir: this.options.cacheDir,
+			runtimeConfig: resolvedConfig,
+			defaultGpuLayers: this.options.gpuLayers,
+			monitor: options.monitor
+		});
+		const context = await runtimeModel.createContext({ contextSize: resolvedConfig.contextSize ?? this.options.contextSize });
+		options.monitor?.setStatus({
+			message: `Llama model ${model} is ready.`,
+			progress: 1
+		});
+		await disposeRuntimeNode(context);
+		await disposeRuntimeNode(runtimeModel);
+	}
+	async create(options) {
+		const model = options.model || this.options.defaultModel;
+		if (!model) throw new Error("A GGUF model id or runtime model path is required.");
+		const module = await (this.options.loadModule ?? loadLlamaRuntimeModule)();
+		const resolvedConfig = readRuntimeConfig(options.runtimeConfig);
+		const runtimeModel = await loadRuntimeModel({
+			module,
+			model,
+			cacheDir: this.options.cacheDir,
+			runtimeConfig: resolvedConfig,
+			defaultGpuLayers: this.options.gpuLayers,
+			monitor: options.monitor
+		});
+		options.monitor?.setStatus({
+			message: `Llama model ${model} is ready.`,
+			progress: 1
+		});
+		return new LocalLlamaTranslator(module, runtimeModel, {
+			sourceLanguage: options.sourceLanguage,
+			targetLanguage: options.targetLanguage,
+			runtimeConfig: resolvedConfig,
+			factoryOptions: this.options,
+			model
+		});
+	}
+};
+function createLocalLlamaTranslatorFactory(options = {}) {
+	return new LocalLlamaTranslatorFactory(options);
+}
+var LocalLlamaTranslator = class {
+	constructor(module, model, options) {
+		this.module = module;
+		this.model = model;
+		this.options = options;
+	}
+	async *batchTranslate(inputs, options) {
+		for (const [index, input] of inputs.entries()) {
+			throwIfAborted(options?.signal);
+			const context = await this.model.createContext({ contextSize: this.options.runtimeConfig.contextSize ?? this.options.factoryOptions.contextSize });
+			try {
+				const session = new this.module.LlamaChatSession({
+					contextSequence: context.getSequence(),
+					systemPrompt: this.options.runtimeConfig.systemPrompt ?? this.options.factoryOptions.systemPrompt ?? DEFAULT_SYSTEM_PROMPT
+				});
+				try {
+					const output = await session.prompt(buildTranslationPrompt({
+						sourceLanguage: this.options.sourceLanguage,
+						targetLanguage: this.options.targetLanguage,
+						text: input,
+						instructions: options?.instructions,
+						context: options?.context
+					}));
+					throwIfAborted(options?.signal);
+					yield {
+						index,
+						output: output.trim()
+					};
+				} finally {
+					await disposeRuntimeNode(session);
+				}
+			} finally {
+				await disposeRuntimeNode(context);
+			}
+		}
+	}
+	destroy() {
+		disposeRuntimeNode(this.model);
+	}
+};
+async function loadRuntimeModel(input) {
+	input.monitor?.setStatus({ message: `Loading llama model ${input.model}.` });
+	return (await input.module.getLlama()).loadModel({
+		modelPath: resolveModelPath({
+			model: input.model,
+			cacheDir: input.cacheDir,
+			runtimeConfig: input.runtimeConfig
+		}),
+		gpuLayers: input.runtimeConfig.gpuLayers ?? input.defaultGpuLayers
+	});
+}
+function buildTranslationPrompt(input) {
+	const sections = [`Translate the following text from ${input.sourceLanguage} to ${input.targetLanguage}.`, "Return only the translated text."];
+	if (input.instructions?.trim()) sections.push(`Additional instructions:\n${input.instructions.trim()}`);
+	if (input.context?.trim()) sections.push(`Translation context:\n${input.context.trim()}`);
+	sections.push(`Text:\n${input.text}`);
+	return sections.join("\n\n");
+}
+async function loadLlamaRuntimeModule() {
+	return await import("node-llama-cpp");
+}
+function resolveModelPath(input) {
+	if (input.runtimeConfig.modelPath) return input.runtimeConfig.modelPath;
+	if (input.cacheDir) return join(input.cacheDir, "models", input.model);
+	return input.model;
+}
+function readRuntimeConfig(runtimeConfig) {
+	return {
+		modelPath: readString(runtimeConfig, "modelPath"),
+		contextSize: readNumber(runtimeConfig, "contextSize"),
+		gpuLayers: readNumber(runtimeConfig, "gpuLayers"),
+		systemPrompt: readString(runtimeConfig, "systemPrompt")
+	};
+}
+function readString(record, key) {
+	const value = record?.[key];
+	return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function readNumber(record, key) {
+	const value = record?.[key];
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+async function disposeRuntimeNode(value) {
+	await value?.dispose?.();
+}
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw new DOMException("The operation was aborted.", "AbortError");
+}
+
+//#endregion
+//#region ../local-llama-translator/src/gguf-download-plan.ts
+function resolveGgufModelDownloadPlanFromRepositoryFiles(input) {
+	const groups = dedupeFiles(input.files.filter((file) => file.path.trim().length > 0).map((file) => ({
+		...file,
+		path: normalizePath(file.path)
+	}))).filter((file) => file.path.toLowerCase().endsWith(".gguf")).map((file) => createGroup(file));
+	if (groups.length === 0) return null;
+	const selectedGroup = selectRequestedGroup(groups, input.selectedGroupId) ?? selectPreferredSelectableGroup(groups);
+	const selectedGroupId = selectedGroup?.id;
+	return {
+		modelId: input.modelId,
+		estimatedTotalBytes: selectedGroup?.estimatedTotalBytes,
+		files: selectedGroup?.files ?? [],
+		selectedGroupId,
+		groups: groups.map((group) => ({
+			...group,
+			selected: group.id === selectedGroupId,
+			files: [...group.files]
+		}))
+	};
+}
+function createGroup(file) {
+	const planFile = toPlanFile(file);
+	const baseGroupId = stripGgufExtension(posix.basename(file.path));
+	return {
+		id: file.path,
+		baseGroupId,
+		label: baseGroupId,
+		description: `GGUF runtime file from ${file.path}.`,
+		estimatedTotalBytes: file.sizeBytes,
+		selectable: typeof file.sizeBytes === "number" && file.sizeBytes > 0,
+		selected: false,
+		files: [planFile]
+	};
+}
+function toPlanFile(file) {
+	return {
+		path: file.path,
+		sizeBytes: file.sizeBytes,
+		required: true,
+		etag: file.etag,
+		revision: file.revision,
+		sourceUrl: file.sourceUrl,
+		raw: file.raw
+	};
+}
+function selectRequestedGroup(groups, selectedGroupId) {
+	if (!selectedGroupId) return null;
+	return groups.find((group) => group.selectable && (group.id === selectedGroupId || group.baseGroupId === selectedGroupId)) ?? null;
+}
+function selectPreferredSelectableGroup(groups) {
+	const selectableGroups = groups.filter((group) => group.selectable && group.estimatedTotalBytes !== void 0);
+	if (selectableGroups.length === 0) return null;
+	return selectableGroups.sort((left, right) => {
+		const compatibilityDelta = scorePreferredLlamaGroup(right.baseGroupId ?? right.id) - scorePreferredLlamaGroup(left.baseGroupId ?? left.id);
+		if (compatibilityDelta !== 0) return compatibilityDelta;
+		return (left.estimatedTotalBytes ?? Number.POSITIVE_INFINITY) - (right.estimatedTotalBytes ?? Number.POSITIVE_INFINITY) || left.id.localeCompare(right.id);
+	})[0] ?? null;
+}
+function scorePreferredLlamaGroup(groupId) {
+	const normalized = groupId.toUpperCase();
+	if (normalized.includes("Q4_K_M")) return 5;
+	if (normalized.includes("Q4_K_S")) return 4;
+	if (normalized.includes("Q5_K_M")) return 3;
+	if (normalized.includes("Q5_K_S")) return 2;
+	if (normalized.includes("Q6_K")) return 1;
+	if (normalized.includes("IQ1") || normalized.includes("IQ2") || normalized.includes("IQ3")) return -2;
+	if (normalized.includes("TQ1") || normalized.includes("TQ2") || normalized.includes("1.25BIT")) return -3;
+	return 0;
+}
+function stripGgufExtension(value) {
+	return value.replace(/\.gguf$/iu, "");
+}
+function normalizePath(input) {
+	return input.replace(/^\.\/+/u, "").replace(/\/+/gu, "/");
+}
+function dedupeFiles(files) {
+	const deduped = /* @__PURE__ */ new Map();
+	for (const file of files) deduped.set(file.path, file);
+	return [...deduped.values()];
+}
+
+//#endregion
+export { LocalLlamaTranslatorFactory as n, createLocalLlamaTranslatorFactory as r, resolveGgufModelDownloadPlanFromRepositoryFiles as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openspecui/server",
-  "version": "3.11.1",
+  "version": "3.11.3",
   "type": "module",
   "main": "dist/index.mjs",
   "exports": {
@@ -23,10 +23,9 @@
   "dependencies": {
     "@hono/node-server": "^1.14.1",
     "@huggingface/hub": "^2.12.0",
-    "@huggingface/transformers": "^4.2.0",
     "@lydell/node-pty": "^1.1.0",
-    "@openspecui/core": "3.11.1",
-    "@openspecui/search": "3.11.1",
+    "@openspecui/core": "3.11.3",
+    "@openspecui/search": "3.11.3",
     "@trpc/server": "^11.0.0",
     "better-sqlite3": "^12.5.0",
     "hono": "^4.7.3",
@@ -34,6 +33,13 @@
     "ws": "^8.18.0",
     "zod": "^3.24.1"
   },
+  "// runtime-note": "These heavy runtimes are owned by the host package because translation engine installation is lifecycle-managed at the host boundary.",
+  "// bundle-note": "The translator engine packages keep heavyweight runtime imports external in tsdown output, so this host package remains the install/detect truth during development runs even when the translator adapters are bundled.",
+  "optionalDependencies": {
+    "@huggingface/transformers": "~4.2.0",
+    "ctranslate2": "0.1.0",
+    "node-llama-cpp": "~3.18.1"
+  },
   "devDependencies": {
     "@trpc/client": "^11.7.2",
     "@types/better-sqlite3": "^7.6.13",