@openspecui/server 3.11.2 → 3.11.3

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.2",
+  "version": "3.11.3",
   "type": "module",
   "main": "dist/index.mjs",
   "exports": {
@@ -24,8 +24,8 @@
     "@hono/node-server": "^1.14.1",
     "@huggingface/hub": "^2.12.0",
     "@lydell/node-pty": "^1.1.0",
-    "@openspecui/core": "3.11.2",
-    "@openspecui/search": "3.11.2",
+    "@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,10 +34,11 @@
     "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 runtime imports external in tsdown output, so this host package remains the install/detect truth during development runs.",
+  "// 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"
+    "ctranslate2": "0.1.0",
+    "node-llama-cpp": "~3.18.1"
   },
   "devDependencies": {
     "@trpc/client": "^11.7.2",