@openspecui/server 3.11.2 → 3.11.4

package/dist/src-CZfiVL_-.mjs

@@ -0,0 +1,279 @@
+import { join, posix } from "node:path";
+import { runControlledTranslationTask } from "@openspecui/core/translator";
+
+//#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.");
+		await probeLocalLlamaRuntimeModel({
+			model,
+			cacheDir: this.options.cacheDir,
+			runtimeConfig: options.runtimeConfig,
+			loadModule: this.options.loadModule,
+			contextSize: this.options.contextSize,
+			gpuLayers: this.options.gpuLayers,
+			monitor: options.monitor
+		});
+	}
+	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);
+}
+async function probeLocalLlamaRuntimeModel(input) {
+	const module = await (input.loadModule ?? loadLlamaRuntimeModule)();
+	const resolvedConfig = readRuntimeConfig(input.runtimeConfig);
+	const runtimeModel = await loadRuntimeModel({
+		module,
+		model: input.model,
+		cacheDir: input.cacheDir,
+		runtimeConfig: resolvedConfig,
+		defaultGpuLayers: input.gpuLayers,
+		monitor: input.monitor
+	});
+	try {
+		const context = await runtimeModel.createContext({ contextSize: resolvedConfig.contextSize ?? input.contextSize });
+		try {
+			input.monitor?.setStatus({
+				message: `Llama model ${input.model} is ready.`,
+				progress: 1
+			});
+		} finally {
+			await disposeRuntimeNode(context);
+		}
+	} finally {
+		await disposeRuntimeNode(runtimeModel);
+	}
+}
+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()) {
+			const controlled = await runControlledTranslationTask(async (signal) => {
+				throwIfAborted(signal);
+				const context = await this.model.createContext({
+					contextSize: this.options.runtimeConfig.contextSize ?? this.options.factoryOptions.contextSize,
+					batchSize: this.options.runtimeConfig.batchSize ?? this.options.factoryOptions.batchSize,
+					flashAttention: this.options.runtimeConfig.flashAttention ?? this.options.factoryOptions.flashAttention
+				});
+				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(signal);
+						return output.trim();
+					} finally {
+						await disposeRuntimeNode(session);
+					}
+				} finally {
+					await disposeRuntimeNode(context);
+				}
+			}, options);
+			if (controlled.ok) {
+				yield {
+					index,
+					output: controlled.value
+				};
+				continue;
+			}
+			yield {
+				index,
+				error: controlled.error
+			};
+		}
+	}
+	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,
+		useMmap: input.runtimeConfig.useMmap,
+		useMlock: input.runtimeConfig.useMlock,
+		defaultContextFlashAttention: input.runtimeConfig.flashAttention
+	});
+}
+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: readGpuLayers(runtimeConfig?.gpuLayers),
+		systemPrompt: readString(runtimeConfig, "systemPrompt"),
+		batchSize: readNumber(runtimeConfig, "batchSize"),
+		flashAttention: readBoolean(runtimeConfig, "flashAttention"),
+		useMmap: readBoolean(runtimeConfig, "useMmap"),
+		useMlock: readBoolean(runtimeConfig, "useMlock")
+	};
+}
+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 readBoolean(record, key) {
+	const value = record?.[key];
+	return typeof value === "boolean" ? value : void 0;
+}
+function readGpuLayers(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (value === "auto" || value === "max") return value;
+}
+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 { probeLocalLlamaRuntimeModel as i, LocalLlamaTranslatorFactory as n, createLocalLlamaTranslatorFactory as r, resolveGgufModelDownloadPlanFromRepositoryFiles as t };

package/dist/{src-BHeS1bxo.mjs → src-DTmyMpWU.mjs}

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { runControlledTranslationTask } from "@openspecui/core/translator";
 
 //#region ../../node_modules/.pnpm/@tanstack+devtools-event-client@0.4.3/node_modules/@tanstack/devtools-event-client/dist/esm/plugin.js
 var EventClient = class {
@@ -13383,31 +13384,42 @@ var OpenAICompletionTranslator = class {
 		this.options = options;
 	}
 	async *batchTranslate(inputs, options) {
-		const abortController = createAbortController(options?.signal);
-		const adapter = createConfiguredOpenAiAdapter({
-			model: this.options.model,
-			token: this.options.token,
-			baseUrl: this.options.baseUrl
-		});
-		for (const [index, source] of inputs.entries()) yield {
-			index,
-			output: (await chat({
-				adapter,
-				stream: false,
-				temperature: 0,
-				abortController,
-				systemPrompts: [[
-					"You are a translation engine.",
-					`Translate from ${this.options.sourceLanguage} to ${this.options.targetLanguage}.`,
-					options?.instructions ?? "Translate the source accurately.",
-					"Return only the translated source without commentary."
-				].filter(Boolean).join("\n")],
-				messages: [{
-					role: "user",
-					content: [options?.context ? `<context>\n${options.context}\n</context>` : "", `<source>\n${source}\n</source>`].filter(Boolean).join("\n\n")
-				}]
-			})).trim()
-		};
+		for (const [index, source] of inputs.entries()) {
+			const controlled = await runControlledTranslationTask(async (signal) => {
+				const abortController = createAbortController(signal);
+				return (await chat({
+					adapter: createConfiguredOpenAiAdapter({
+						model: this.options.model,
+						token: this.options.token,
+						baseUrl: this.options.baseUrl
+					}),
+					stream: false,
+					temperature: 0,
+					abortController,
+					systemPrompts: [[
+						"You are a translation engine.",
+						`Translate from ${this.options.sourceLanguage} to ${this.options.targetLanguage}.`,
+						options?.instructions ?? "Translate the source accurately.",
+						"Return only the translated source without commentary."
+					].filter(Boolean).join("\n")],
+					messages: [{
+						role: "user",
+						content: [options?.context ? `<context>\n${options.context}\n</context>` : "", `<source>\n${source}\n</source>`].filter(Boolean).join("\n\n")
+					}]
+				})).trim();
+			}, options);
+			if (controlled.ok) {
+				yield {
+					index,
+					output: controlled.value
+				};
+				continue;
+			}
+			yield {
+				index,
+				error: controlled.error
+			};
+		}
 	}
 };
 function createAbortController(signal) {

package/dist/src-DVJf9xbi.mjs

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

package/dist/{src--4tprY9A.mjs → src-DfagK_w9.mjs}

@@ -1,5 +1,6 @@
 import { join } from "node:path";
 import { readFile } from "node:fs/promises";
+import { runControlledTranslationTask } from "@openspecui/core/translator";
 import "@openspecui/core/local-download-profiles";
 
 //#region ../local-translator/src/index.ts
@@ -27,18 +28,28 @@ var LocalTranslator = class {
 		this.languages = languages;
 	}
 	async *batchTranslate(inputs, options) {
-		throwIfAborted(options?.signal);
-		const result = await this.pipeline(inputs, {
-			src_lang: this.languages.sourceLanguage,
-			tgt_lang: this.languages.targetLanguage,
-			signal: options?.signal
-		});
-		throwIfAborted(options?.signal);
-		const outputs = readTranslatedOutputs(result, inputs.length);
-		for (const [index, output] of outputs.entries()) yield {
-			index,
-			output
-		};
+		for (const [index, input] of inputs.entries()) {
+			const controlled = await runControlledTranslationTask(async (signal) => {
+				const result = await this.pipeline(input, {
+					src_lang: this.languages.sourceLanguage,
+					tgt_lang: this.languages.targetLanguage,
+					signal
+				});
+				throwIfAborted(signal);
+				return readTranslatedOutputs(result, 1)[0] ?? "";
+			}, options);
+			if (controlled.ok) {
+				yield {
+					index,
+					output: controlled.value
+				};
+				continue;
+			}
+			yield {
+				index,
+				error: controlled.error
+			};
+		}
 	}
 	destroy() {
 		this.pipeline.dispose?.();

package/dist/{src-BJ-K9Dp2.mjs → src-Dh_UAz5C.mjs}

@@ -1,4 +1,5 @@
 import { join, posix } from "node:path";
+import { runControlledTranslationTask } from "@openspecui/core/translator";
 
 //#region ../local-ct2-translator/src/ct2-download-plan.ts
 const CT2_REQUIRED_FILE_NAMES = [
@@ -154,18 +155,30 @@ var LocalCt2Translator = class {
 		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
-		};
+		for (const [index, input] of inputs.entries()) {
+			const controlled = await runControlledTranslationTask(async (signal) => {
+				throwIfAborted(signal);
+				const result = await this.translator.translateBatch([input], {
+					beamSize: this.runtimeConfig.beamSize ?? this.factoryOptions.beamSize,
+					maxBatchSize: this.runtimeConfig.maxBatchSize ?? this.factoryOptions.maxBatchSize,
+					returnScores: false
+				});
+				throwIfAborted(signal);
+				if (result.length !== 1) throw new Error(`CT2 translator returned ${result.length} outputs for 1 input.`);
+				return result[0]?.text ?? "";
+			}, options);
+			if (controlled.ok) {
+				yield {
+					index,
+					output: controlled.value
+				};
+				continue;
+			}
+			yield {
+				index,
+				error: controlled.error
+			};
+		}
 	}
 };
 async function createRuntimeTranslator(options, modelPath, runtimeConfig) {

package/dist/{src-8bHfOTUF.mjs → src-cslnzFaN.mjs}

@@ -1,3 +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";
+import { a as resolveCt2ModelDownloadPlanFromRepositoryFiles, i as CT2_REQUIRED_FILE_NAMES, n as createLocalCt2TranslatorFactory, r as CT2_OPTIONAL_FILE_NAMES, t as LocalCt2TranslatorFactory } from "./src-Dh_UAz5C.mjs";
 
 export { createLocalCt2TranslatorFactory };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openspecui/server",
-  "version": "3.11.2",
+  "version": "3.11.4",
   "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.4",
+    "@openspecui/search": "3.11.4",
     "@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",