@openspecui/server 3.11.1 → 3.11.2

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openspecui/server",
-  "version": "3.11.1",
+  "version": "3.11.2",
   "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.2",
+    "@openspecui/search": "3.11.2",
     "@trpc/server": "^11.0.0",
     "better-sqlite3": "^12.5.0",
     "hono": "^4.7.3",
@@ -34,6 +33,12 @@
     "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 runtime imports external in tsdown output, so this host package remains the install/detect truth during development runs.",
+  "optionalDependencies": {
+    "@huggingface/transformers": "~4.2.0",
+    "ctranslate2": "0.1.0"
+  },
   "devDependencies": {
     "@trpc/client": "^11.7.2",
     "@types/better-sqlite3": "^7.6.13",