aiex-cli 0.0.6-beta.1 → 0.0.6-beta.2

package/README.md

@@ -208,6 +208,7 @@ aiex works with any OpenAI-compatible API provider. Configure in the Web UI (AI
 
 - **Provider** — Set your base URL and API key
 - **Models** — Add models with vision and/or structured output capabilities
+- **Documents** — Choose a PDF converter (`unpdf`, `mineru`, `mineru_api`, or `external`); image input automatically uses a vision model when available, otherwise system OCR on supported platforms
 - **Prompts** — Customize system and user prompt templates with `{schema}` and `{text}` placeholders
 - **Integrations** — Optionally connect Notion from AI Settings; use Connect & Map to bind a schema to an existing Notion data source
 

package/dist/cli.mjs

@@ -1,4 +1,4 @@
-import { A as doctorDiagnosticsTableRows, C as createConfig, D as package_default, E as name, O as version, S as AIConfigSchema, T as description, _ as DEFAULT_MINERU_API_CONFIG, a as parseJsonSchema, b as PLACEHOLDER_SCHEMA, c as recognizeImageText, d as t, f as getDefaultAIConfig, g as DEFAULT_MARKITDOWN_CONFIG, h as DEFAULT_MARKER_CONFIG, i as JsonSchemaDefinitionSchema, j as formatDoctorDiagnosticsJson, l as shouldUseImageOcrFallback, m as writeAIConfig, n as createMigrationConfig, o as toSnakeCase, p as readAIConfig, s as generateDrizzleSchema, t as collectDoctorDiagnostics, u as initI18n, v as DEFAULT_MINERU_CONFIG, w as seedConfig, x as PLACEHOLDER_TEXT, y as DEFAULT_PROMPT_CONFIG } from "./doctor-collector-hWEvJ4lw.mjs";
+import { C as description, E as version, O as doctorDiagnosticsTableRows, S as seedConfig, T as package_default, _ as DEFAULT_PROMPT_CONFIG, a as parseJsonSchema, b as AIConfigSchema, c as recognizeImageText, d as t, f as getDefaultAIConfig, g as DEFAULT_MINERU_CONFIG, h as DEFAULT_MINERU_API_CONFIG, i as JsonSchemaDefinitionSchema, k as formatDoctorDiagnosticsJson, l as shouldUseImageOcrFallback, m as writeAIConfig, n as createMigrationConfig, o as toSnakeCase, p as readAIConfig, s as generateDrizzleSchema, t as collectDoctorDiagnostics, u as initI18n, v as PLACEHOLDER_SCHEMA, w as name, x as createConfig, y as PLACEHOLDER_TEXT } from "./doctor-collector-CGo5dgHm.mjs";
 import { createRequire } from "node:module";
 import fs from "node:fs/promises";
 import os from "node:os";
@@ -21,6 +21,8 @@ import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 import { APICallError, Output, generateText, jsonSchema } from "ai";
 import pRetry from "p-retry";
 import mime from "mime";
+import { TextDecoder, promisify } from "node:util";
+import { fileTypeFromBuffer, fileTypeFromFile } from "file-type";
 import { jsonrepair } from "jsonrepair";
 import { LangfuseSpanProcessor } from "@langfuse/otel";
 import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
@@ -31,7 +33,6 @@ import { glob, globSync } from "tinyglobby";
 import { extractText, getDocumentProxy, getMeta } from "unpdf";
 import AdmZip from "adm-zip";
 import { execFile } from "node:child_process";
-import { promisify } from "node:util";
 import * as chokidar from "chokidar";
 import { serve } from "@hono/node-server";
 import open from "open";
@@ -12859,13 +12860,65 @@ async function withRetry(fn, onRetry, maxRetries = 5) {
 	});
 }
 
+//#endregion
+//#region src/core/input-file-kind.ts
+const UTF8_DECODER = new TextDecoder("utf-8", { fatal: true });
+const SVG_START_RE = /^\s*<svg[\s>]/i;
+const SVG_ANY_RE = /<svg[\s>]/i;
+function isSupportedImageMime(mime$1) {
+	return !!mime$1 && [
+		"image/png",
+		"image/jpeg",
+		"image/webp"
+	].includes(mime$1);
+}
+function detectTextKind(buffer) {
+	try {
+		const text$1 = UTF8_DECODER.decode(buffer);
+		if (SVG_START_RE.test(text$1) || SVG_ANY_RE.test(text$1.slice(0, 4096))) return {
+			kind: "unsupported",
+			mime: "image/svg+xml"
+		};
+		return {
+			kind: "text",
+			mime: "text/plain"
+		};
+	} catch {
+		return { kind: "unsupported" };
+	}
+}
+async function detectInputFileKind(filePath) {
+	const detected = await fileTypeFromFile(filePath);
+	if (detected?.mime === "application/pdf") return {
+		kind: "pdf",
+		mime: detected.mime
+	};
+	if (isSupportedImageMime(detected?.mime)) return {
+		kind: "image",
+		mime: detected?.mime
+	};
+	return detectTextKind(await fs.readFile(filePath));
+}
+async function detectInputBufferKind(buffer) {
+	const detected = await fileTypeFromBuffer(buffer);
+	if (detected?.mime === "application/pdf") return {
+		kind: "pdf",
+		mime: detected.mime
+	};
+	if (isSupportedImageMime(detected?.mime)) return {
+		kind: "image",
+		mime: detected?.mime
+	};
+	return detectTextKind(buffer);
+}
+
 //#endregion
 //#region src/core/ai-extraction/file-utils.ts
-function detectMimeType(filePath) {
-	return mime.getType(filePath) ?? "application/octet-stream";
+async function detectMimeType(filePath) {
+	return (await detectInputFileKind(filePath)).mime ?? mime.getType(filePath) ?? "application/octet-stream";
 }
 async function readFilePart(filePath) {
-	const mimeStr = detectMimeType(filePath);
+	const mimeStr = await detectMimeType(filePath);
 	const buffer = await fs.readFile(filePath);
 	const name$1 = path.basename(filePath);
 	if (mimeStr.startsWith("image/")) return {
@@ -13212,7 +13265,7 @@ async function extractStructuredData(input) {
 		error: t("errors.ai.apiKeyMissing")
 	};
 	const useFileContent = !!file;
-	const isImageFile = useFileContent && detectMimeType(file).startsWith("image/");
+	const isImageFile = (useFileContent ? await detectMimeType(file) : "").startsWith("image/");
 	const inputTokens = text$1 ? Math.ceil(text$1.length / 2) : void 0;
 	const fieldCount = schema.properties ? Object.keys(schema.properties).length : 0;
 	const outputTokens = fieldCount > 0 ? fieldCount * 80 : void 0;
@@ -13953,30 +14006,10 @@ const MAX_UPLOAD_SIZE = 30 * 1024 * 1024;
 const MAX_UPLOAD_SIZE_TEXT = "30MB";
 const SUPPORTED_FILE_TYPES_TEXT = "images, PDF, text, markdown, CSV, JSON, HTML, XML, YAML";
 const MISSING_UPLOAD_FILE_TEXT = t("errors.file.missingUpload");
-const SUPPORTED_MIME_TYPES = new Set([
-	"image/png",
-	"image/jpeg",
-	"image/gif",
-	"image/webp",
-	"image/bmp",
-	"image/svg+xml",
-	"application/pdf",
-	"text/plain",
-	"text/markdown",
-	"text/csv",
-	"application/json",
-	"text/html",
-	"text/xml",
-	"application/x-yaml",
-	"text/yaml"
-]);
 const MIME_TO_EXT = {
 	"image/png": "png",
 	"image/jpeg": "jpg",
-	"image/gif": "gif",
 	"image/webp": "webp",
-	"image/bmp": "bmp",
-	"image/svg+xml": "svg",
 	"application/pdf": "pdf",
 	"text/plain": "txt",
 	"text/markdown": "md",
@@ -13993,8 +14026,8 @@ function bytesToMB(bytes) {
 function getExtensionFromMime(mimeType) {
 	return MIME_TO_EXT[mimeType];
 }
-function isAllowedMimeType(mimeType) {
-	return SUPPORTED_MIME_TYPES.has(mimeType);
+function getExtensionForDetectedFile(mimeType) {
+	return mimeType ? getExtensionFromMime(mimeType) ?? "txt" : "txt";
 }
 function unsupportedFileTypeMessage(mimeType) {
 	return t("errors.file.unsupportedType", {
@@ -14011,14 +14044,16 @@ var FileValidationError = class extends Error {
 		this.name = "FileValidationError";
 	}
 };
-function validateFileUpload(file) {
+async function validateFileUploadContent(file, buffer) {
 	if (file.size === 0) throw new FileValidationError(t("errors.file.empty"));
 	if (file.size > MAX_UPLOAD_SIZE) throw new FileValidationError(t("errors.file.sizeExceeded", {
 		size: bytesToMB(file.size).toFixed(1),
 		limit: MAX_UPLOAD_SIZE_TEXT,
 		file: file.name
 	}));
-	if (!isAllowedMimeType(file.type)) throw new FileValidationError(unsupportedFileTypeMessage(file.type));
+	const detected = await detectInputBufferKind(buffer);
+	if (detected.kind === "unsupported") throw new FileValidationError(unsupportedFileTypeMessage(detected.mime ?? (file.type || "application/octet-stream")));
+	return detected.mime ?? "text/plain";
 }
 
 //#endregion
@@ -14280,14 +14315,6 @@ function createPdfConverter(config) {
 			return withFallback(new ExternalCommandPdfConverter("mineru", mineruConfig), mineruConfig);
 		}
 		if (config.converter === "mineru_api") return new MineruApiPdfConverter(config.mineruApi ?? DEFAULT_MINERU_API_CONFIG);
-		if (config.converter === "markitdown") {
-			const markitdownConfig = config.markitdown ?? DEFAULT_MARKITDOWN_CONFIG;
-			return withFallback(new ExternalCommandPdfConverter("markitdown", markitdownConfig), markitdownConfig);
-		}
-		if (config.converter === "marker") {
-			const markerConfig = config.marker ?? DEFAULT_MARKER_CONFIG;
-			return withFallback(new ExternalCommandPdfConverter("marker", markerConfig), markerConfig);
-		}
 		if (config.converter === "external") {
 			if (!config.external) throw new Error(t("errors.pdf.externalNotConfigured"));
 			return new ExternalCommandPdfConverter("external", config.external);
@@ -14309,12 +14336,32 @@ const FILE_PART_EXTENSIONS = new Set([
 	"png",
 	"jpg",
 	"jpeg",
-	"gif",
-	"webp",
-	"bmp",
-	"svg"
+	"webp"
 ]);
 const PDF_EXT_RE = /\.pdf$/i;
+async function describeExtractFileInput(filePath, aiConfig, modelOverride) {
+	const detected = await detectInputFileKind(filePath);
+	if (detected.kind === "image") return {
+		kind: "image",
+		mime: detected.mime,
+		handler: shouldUseImageOcrFallback(aiConfig, modelOverride) ? "image_local_ocr" : "image_vision"
+	};
+	if (detected.kind === "pdf") {
+		const converter = createPdfConverter(aiConfig?.pdf);
+		return {
+			kind: "pdf",
+			mime: detected.mime,
+			handler: "pdf_converter",
+			converter: converter.name
+		};
+	}
+	if (detected.kind === "text") return {
+		kind: "text",
+		mime: detected.mime,
+		handler: "text"
+	};
+	throw new Error(unsupportedFileTypeMessage(detected.mime ?? "application/octet-stream"));
+}
 async function readExtractFileInput(filePath, aiConfig, modelOverride) {
 	const stat = fs$1.statSync(filePath);
 	if (stat.size > MAX_UPLOAD_SIZE) throw new Error(t("errors.file.sizeExceeded", {
@@ -14322,19 +14369,23 @@ async function readExtractFileInput(filePath, aiConfig, modelOverride) {
 		limit: MAX_UPLOAD_SIZE_TEXT,
 		file: filePath
 	}));
-	const ext = path.extname(filePath).toLowerCase().replace(".", "");
-	if (FILE_PART_EXTENSIONS.has(ext)) {
-		if (shouldUseImageOcrFallback(aiConfig, modelOverride)) {
-			const result = await recognizeImageText(filePath, aiConfig?.image);
+	const inputProcessing = await describeExtractFileInput(filePath, aiConfig, modelOverride);
+	if (inputProcessing.kind === "image") {
+		if (inputProcessing.handler === "image_local_ocr") {
+			const result = await recognizeImageText(filePath);
 			consola.info(t("command.extract.file.ocrText", { confidence: (result.confidence * 100).toFixed(1) }));
-			return { text: result.text };
+			return {
+				text: result.text,
+				inputProcessing
+			};
 		}
 		return {
 			text: "",
-			filePath
+			filePath,
+			inputProcessing
 		};
 	}
-	if (ext === "pdf") {
+	if (inputProcessing.kind === "pdf") {
 		const buffer = await fs.readFile(filePath);
 		const converter = createPdfConverter(aiConfig?.pdf);
 		const result = await converter.convert(buffer, filePath);
@@ -14352,9 +14403,16 @@ async function readExtractFileInput(filePath, aiConfig, modelOverride) {
 			await fs.writeFile(fallbackMd, result.text);
 			consola.info(t("command.extract.file.markdownSaved", { path: fallbackMd }));
 		}
-		return { text: result.text };
+		return {
+			text: result.text,
+			inputProcessing
+		};
 	}
-	return { text: await fs.readFile(filePath, "utf-8") };
+	if (inputProcessing.kind === "text") return {
+		text: await fs.readFile(filePath, "utf-8"),
+		inputProcessing
+	};
+	throw new Error(unsupportedFileTypeMessage(inputProcessing.mime ?? "application/octet-stream"));
 }
 
 //#endregion
@@ -14610,6 +14668,10 @@ async function extractSingle(aiexDir, config, aiConfig, schemaName, text$1, file
 		tokensUsed: result.tokensUsed
 	};
 }
+function formatInputProcessing$1(input) {
+	const handler = input.converter ? `${input.handler}(${input.converter})` : input.handler;
+	return `${input.mime ?? input.kind} -> ${handler}`;
+}
 async function runAuditedExtraction(options) {
 	const { aiexDir, config, aiConfig, schemaName, source, modelOverride, retryOf, insert, force, quiet = false } = options;
 	let fileHash;
@@ -14650,7 +14712,8 @@ async function runAuditedExtraction(options) {
 					outputName: existing.outputName,
 					tablesInserted: existing.tablesInserted,
 					notionPages: existing.notionPages,
-					tokensUsed: existing.tokensUsed
+					tokensUsed: existing.tokensUsed,
+					inputProcessing: existing.inputProcessing
 				};
 			}
 		}
@@ -14672,10 +14735,14 @@ async function runAuditedExtraction(options) {
 	try {
 		let text$1 = "";
 		let filePath;
+		let inputProcessing;
 		if (source.type === "file") {
 			const input = await readExtractFileInput(source.filePath, aiConfig, modelOverride);
 			text$1 = input.text;
 			filePath = input.filePath;
+			inputProcessing = input.inputProcessing;
+			if (!quiet) consola.info(`Input: ${formatInputProcessing$1(inputProcessing)}`);
+			await updateExtractionAuditRecord(aiexDir, audit.id, { inputProcessing });
 		} else text$1 = source.text;
 		const r = await extractSingle(aiexDir, config, aiConfig, schemaName, text$1, filePath, modelOverride, {
 			quiet,
@@ -14701,7 +14768,8 @@ async function runAuditedExtraction(options) {
 					success: false,
 					error: error instanceof Error ? error.message : String(error),
 					auditId: audit.id,
-					fileHash
+					fileHash,
+					inputProcessing
 				};
 			}
 			const updated = await updateExtractionAuditRecord(aiexDir, audit.id, {
@@ -14721,7 +14789,8 @@ async function runAuditedExtraction(options) {
 				notionPages: updated.notionPages,
 				tokensUsed: updated.tokensUsed,
 				auditId: updated.id,
-				fileHash
+				fileHash,
+				inputProcessing: updated.inputProcessing
 			};
 		} else {
 			await updateExtractionAuditRecord(aiexDir, audit.id, {
@@ -14734,7 +14803,8 @@ async function runAuditedExtraction(options) {
 				success: false,
 				error: r.error,
 				auditId: audit.id,
-				fileHash
+				fileHash,
+				inputProcessing
 			};
 		}
 	} catch (e) {
@@ -14938,6 +15008,11 @@ function isExtractSubCommand(rawArgs) {
 function formatSource(source) {
 	return source.type === "file" ? source.fileName || "file" : "unknown";
 }
+function formatInputProcessing(input) {
+	if (!input) return "";
+	const handler = input.converter ? `${input.handler}(${input.converter})` : input.handler;
+	return ` [${input.mime ?? input.kind} -> ${handler}]`;
+}
 async function loadConfiguredAI(aiexDir) {
 	const aiConfig = await readAIConfig(aiexDir);
 	if (!aiConfig) {
@@ -14980,7 +15055,7 @@ const historyCommand = defineCommand({
 		}
 		for (const record of records) {
 			const suffix = record.error ? ` — ${record.error}` : record.outputName ? ` — ${record.outputName}` : "";
-			consola.info(`${record.status.padEnd(9)} ${record.id}  ${record.schemaName}  ${formatSource(record.source)}${suffix}`);
+			consola.info(`${record.status.padEnd(9)} ${record.id}  ${record.schemaName}  ${formatSource(record.source)}${formatInputProcessing(record.inputProcessing)}${suffix}`);
 		}
 	}
 });
@@ -15493,10 +15568,7 @@ const SUPPORTED_EXTENSIONS = new Set([
 	"png",
 	"jpg",
 	"jpeg",
-	"gif",
 	"webp",
-	"bmp",
-	"svg",
 	"pdf",
 	"txt",
 	"md",
@@ -15909,7 +15981,8 @@ async function listExtractions(config) {
 				modifiedAt: stat.mtime.toISOString(),
 				notionStatus: notionPages ? "synced" : audit?.status === "failed" ? "failed" : "not_synced",
 				notionPages,
-				notionError: !notionPages && audit?.status === "failed" ? audit.error : void 0
+				notionError: !notionPages && audit?.status === "failed" ? audit.error : void 0,
+				inputProcessing: audit?.inputProcessing
 			});
 		} catch {
 			continue;
@@ -16180,10 +16253,9 @@ function getFormFile(value) {
 function safeUploadName(name$1) {
 	return path.basename(name$1).replace(/[^\w.-]/g, "_") || "upload.txt";
 }
-function safeUploadNameForMime(file) {
+function safeUploadNameForMime(file, mimeType) {
 	const safeName = safeUploadName(file.name);
-	const ext = getExtensionFromMime(file.type);
-	if (!ext) throw new FileValidationError(unsupportedFileTypeMessage(file.type));
+	const ext = getExtensionForDetectedFile(mimeType);
 	return `${path.parse(safeName).name || "upload"}.${ext}`;
 }
 function jsonResponse(body, status) {
@@ -16193,10 +16265,10 @@ function jsonResponse(body, status) {
 	});
 }
 async function saveUploadToFile(file, uploadsDir, id) {
-	validateFileUpload(file);
-	await fs.mkdir(uploadsDir, { recursive: true });
-	const filePath = path.join(uploadsDir, `${id}-${safeUploadNameForMime(file)}`);
 	const buffer = Buffer.from(await file.arrayBuffer());
+	const mimeType = await validateFileUploadContent(file, buffer);
+	await fs.mkdir(uploadsDir, { recursive: true });
+	const filePath = path.join(uploadsDir, `${id}-${safeUploadNameForMime(file, mimeType)}`);
 	await fs.writeFile(filePath, buffer);
 	return filePath;
 }
@@ -16286,7 +16358,8 @@ function extractRoutes(config) {
 				tablesInserted: result.tablesInserted,
 				notionPages: result.notionPages,
 				tokensUsed: result.tokensUsed,
-				auditId: result.auditId
+				auditId: result.auditId,
+				inputProcessing: result.inputProcessing
 			}, 200);
 		} catch (error) {
 			if (isMissingUploadFileError(error)) return c.json({
@@ -16353,7 +16426,8 @@ function extractRoutes(config) {
 			tablesInserted: result.tablesInserted,
 			notionPages: result.notionPages,
 			tokensUsed: result.tokensUsed,
-			auditId: result.auditId
+			auditId: result.auditId,
+			inputProcessing: result.inputProcessing
 		}, 200);
 	});
 	app.delete("/extract/records/:id", async (c) => {

package/dist/{doctor-collector-hWEvJ4lw.mjs → doctor-collector-CGo5dgHm.mjs}

@@ -74,7 +74,7 @@ function doctorDiagnosticsTableRows(d) {
 //#endregion
 //#region package.json
 var name = "aiex-cli";
-var version = "0.0.6-beta.1";
+var version = "0.0.6-beta.2";
 var description = "JSON Schema → SQLite with AI-powered data extraction";
 var package_default = {
 	name,
@@ -155,6 +155,7 @@ var package_default = {
 		"es-toolkit": "catalog:",
 		"esbuild": "catalog:",
 		"execa": "catalog:",
+		"file-type": "catalog:",
 		"hono": "catalog:",
 		"i18next": "catalog:",
 		"i18next-fs-backend": "catalog:",
@@ -229,12 +230,13 @@ const PromptConfigSchema = z.object({
 	userTemplate: z.string().min(1)
 });
 const ExtractionConfigSchema = z.object({ outputDir: z.string().min(1) });
+const ImageOcrFallbackSchema = z.preprocess((value) => [
+	"auto",
+	"off",
+	"local"
+].includes(String(value)) ? "localAuto" : value, z.literal("localAuto").default("localAuto").optional());
 const ImageOcrConfigSchema = z.object({
-	ocrFallback: z.enum([
-		"auto",
-		"off",
-		"local"
-	]).default("auto").optional(),
+	ocrFallback: ImageOcrFallbackSchema,
 	ocrLanguages: z.string().min(1).optional(),
 	ocrMinConfidence: z.number().min(0).max(1).optional()
 });
@@ -253,21 +255,30 @@ const MineruApiPdfConverterConfigSchema = z.object({
 	enableFormula: z.boolean().optional(),
 	enableTable: z.boolean().optional()
 });
-const PdfConfigSchema = z.object({
+const PdfConfigSchema = z.preprocess((value) => {
+	if (!value || typeof value !== "object") return value;
+	const config = { ...value };
+	if (config.converter === "markitdown" && config.markitdown) {
+		config.converter = "external";
+		config.external = config.markitdown;
+	} else if (config.converter === "marker" && config.marker) {
+		config.converter = "external";
+		config.external = config.marker;
+	} else if (config.converter === "markitdown" || config.converter === "marker") config.converter = "unpdf";
+	delete config.markitdown;
+	delete config.marker;
+	return config;
+}, z.object({
 	converter: z.enum([
 		"unpdf",
 		"mineru",
 		"mineru_api",
-		"markitdown",
-		"marker",
 		"external"
 	]),
 	mineru: ExternalPdfConverterConfigSchema.optional(),
 	mineruApi: MineruApiPdfConverterConfigSchema.optional(),
-	markitdown: ExternalPdfConverterConfigSchema.optional(),
-	marker: ExternalPdfConverterConfigSchema.optional(),
 	external: ExternalPdfConverterConfigSchema.optional()
-});
+}));
 const LangfuseConfigSchema = z.object({
 	publicKey: z.string(),
 	secretKey: z.string(),
@@ -336,11 +347,6 @@ Extraction requirements:
 {text}`
 };
 const DEFAULT_EXTRACTION_CONFIG = { outputDir: ".aiex/extracted" };
-const DEFAULT_IMAGE_OCR_CONFIG = {
-	ocrFallback: "auto",
-	ocrLanguages: "en-US, zh-Hans",
-	ocrMinConfidence: 0
-};
 const DEFAULT_MINERU_CONFIG = {
 	command: "mineru",
 	args: [
@@ -352,26 +358,6 @@ const DEFAULT_MINERU_CONFIG = {
 	timeout: 600,
 	fallbackToUnpdf: true
 };
-const DEFAULT_MARKITDOWN_CONFIG = {
-	command: "markitdown",
-	args: [
-		"{input}",
-		"-o",
-		"{outputDir}/{basename}.md"
-	],
-	timeout: 600,
-	fallbackToUnpdf: true
-};
-const DEFAULT_MARKER_CONFIG = {
-	command: "marker_single",
-	args: [
-		"{input}",
-		"--output_dir",
-		"{outputDir}"
-	],
-	timeout: 600,
-	fallbackToUnpdf: true
-};
 const DEFAULT_MINERU_API_CONFIG = {
 	token: "",
 	baseURL: "https://mineru.net/api/v4",
@@ -383,15 +369,12 @@ const DEFAULT_MINERU_API_CONFIG = {
 const DEFAULT_PDF_CONFIG = {
 	converter: "unpdf",
 	mineru: DEFAULT_MINERU_CONFIG,
-	mineruApi: DEFAULT_MINERU_API_CONFIG,
-	markitdown: DEFAULT_MARKITDOWN_CONFIG,
-	marker: DEFAULT_MARKER_CONFIG
+	mineruApi: DEFAULT_MINERU_API_CONFIG
 };
 const DEFAULT_AI_CONFIG = {
 	provider: DEFAULT_PROVIDER_CONFIG,
 	prompt: DEFAULT_PROMPT_CONFIG,
 	extraction: DEFAULT_EXTRACTION_CONFIG,
-	image: DEFAULT_IMAGE_OCR_CONFIG,
 	pdf: DEFAULT_PDF_CONFIG,
 	webhook: {
 		enabled: false,
@@ -791,7 +774,7 @@ const en = {
 		imageInput: "Image Input",
 		imageInputSummary: {
 			visionModel: "Image files will use your configured vision model first.",
-			ocrFallback: "No vision model is configured, and local OCR fallback is disabled.",
+			ocrFallback: "No vision model is configured, and local OCR is unavailable.",
 			ocrLocal: "No vision model is configured. Image text will require local OCR on macOS or Windows.",
 			ocrAuto: "No vision model is configured. On macOS or Windows, local OCR will be tried automatically for text-heavy images."
 		},
@@ -799,7 +782,7 @@ const en = {
 		noVisionModel: "No vision model",
 		advancedImageSettings: "Advanced image settings",
 		hideAdvancedImageSettings: "Hide advanced image settings",
-		ocrFallback: "OCR fallback",
+		ocrFallback: "Local OCR fallback",
 		ocrLanguages: "Languages",
 		ocrMinConfidence: "Minimum confidence",
 		ocrHint: "Image extraction always prefers a vision model. OCR fallback is only used when no vision model is available.",
@@ -877,15 +860,9 @@ const en = {
 		converterOptions: {
 			unpdf: "Built-in text extraction (unpdf)",
 			mineru: "MinerU (mineru)",
-			markitdown: "MarkItDown (markitdown)",
-			marker: "Marker (marker_single)",
 			external: "Custom External Command"
 		},
-		ocrFallbackOptions: {
-			auto: "Auto on macOS or Windows when no vision model exists",
-			off: "Off",
-			local: "Require local OCR"
-		}
+		ocrFallbackOptions: { localAuto: "Vision model or local OCR" }
 	},
 	prompt: {
 		defaultSystem: `You are a professional data extraction assistant. Your task is to extract structured data from text and return a JSON object based on the data structure definition provided below.
@@ -956,7 +933,7 @@ async function initI18n(lng) {
 			fallbackLng: "en",
 			resources: {
 				"en": { translation: en },
-				"zh-CN": { translation: await import("./zh-CN-Qcn0DHFh.mjs").then((m) => m.zhCN) }
+				"zh-CN": { translation: await import("./zh-CN-wEUNhuHM.mjs").then((m) => m.zhCN) }
 			},
 			interpolation: { escapeValue: false },
 			returnNull: false
@@ -981,7 +958,7 @@ const defaultRuntime = {
 	}
 };
 function imageOcrMode(config) {
-	return config?.ocrFallback ?? "auto";
+	return config?.ocrFallback ?? "localAuto";
 }
 function hasVisionModel(aiConfig, modelOverride) {
 	if (modelOverride) return modelOverride.capabilities.vision;
@@ -989,9 +966,7 @@ function hasVisionModel(aiConfig, modelOverride) {
 }
 function shouldUseImageOcrFallback(aiConfig, modelOverride, runtime = defaultRuntime) {
 	if (hasVisionModel(aiConfig, modelOverride)) return false;
-	const mode = imageOcrMode(aiConfig?.image);
-	if (mode === "off") return false;
-	if (mode === "local") return true;
+	if (imageOcrMode(aiConfig?.image) === "localAuto") return isLocalOcrPlatform(runtime.platform);
 	return isLocalOcrPlatform(runtime.platform);
 }
 function isLocalOcrPlatform(platform) {
@@ -1001,9 +976,7 @@ function parseOcrLanguages(languages) {
 	return (languages ?? DEFAULT_OCR_LANGUAGES).split(",").map((language) => language.trim()).filter(Boolean);
 }
 async function recognizeImageText(imagePath, config, runtime = defaultRuntime) {
-	const mode = imageOcrMode(config);
 	if (!isLocalOcrPlatform(runtime.platform)) throw new Error(t("errors.ocr.platformUnsupported", { platform: runtime.platform }));
-	if (mode === "off") throw new Error(t("errors.ocr.disabled"));
 	let localOcr;
 	try {
 		localOcr = await runtime.loadLocalOcr();
@@ -1536,4 +1509,4 @@ async function collectDoctorDiagnostics(options = {}) {
 }
 
 //#endregion
-export { doctorDiagnosticsTableRows as A, createConfig as C, package_default as D, name as E, version as O, AIConfigSchema as S, description as T, DEFAULT_MINERU_API_CONFIG as _, parseJsonSchema as a, PLACEHOLDER_SCHEMA as b, recognizeImageText as c, t as d, getDefaultAIConfig as f, DEFAULT_MARKITDOWN_CONFIG as g, DEFAULT_MARKER_CONFIG as h, JsonSchemaDefinitionSchema as i, formatDoctorDiagnosticsJson as j, buildDoctorDiagnostics as k, shouldUseImageOcrFallback as l, writeAIConfig as m, createMigrationConfig as n, toSnakeCase as o, readAIConfig as p, generateDrizzleConfig as r, generateDrizzleSchema as s, collectDoctorDiagnostics as t, initI18n as u, DEFAULT_MINERU_CONFIG as v, seedConfig as w, PLACEHOLDER_TEXT as x, DEFAULT_PROMPT_CONFIG as y };
+export { description as C, buildDoctorDiagnostics as D, version as E, doctorDiagnosticsTableRows as O, seedConfig as S, package_default as T, DEFAULT_PROMPT_CONFIG as _, parseJsonSchema as a, AIConfigSchema as b, recognizeImageText as c, t as d, getDefaultAIConfig as f, DEFAULT_MINERU_CONFIG as g, DEFAULT_MINERU_API_CONFIG as h, JsonSchemaDefinitionSchema as i, formatDoctorDiagnosticsJson as k, shouldUseImageOcrFallback as l, writeAIConfig as m, createMigrationConfig as n, toSnakeCase as o, readAIConfig as p, generateDrizzleConfig as r, generateDrizzleSchema as s, collectDoctorDiagnostics as t, initI18n as u, PLACEHOLDER_SCHEMA as v, name as w, createConfig as x, PLACEHOLDER_TEXT as y };

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { A as doctorDiagnosticsTableRows, a as parseJsonSchema, i as JsonSchemaDefinitionSchema, j as formatDoctorDiagnosticsJson, k as buildDoctorDiagnostics, n as createMigrationConfig, r as generateDrizzleConfig, s as generateDrizzleSchema, t as collectDoctorDiagnostics } from "./doctor-collector-hWEvJ4lw.mjs";
+import { D as buildDoctorDiagnostics, O as doctorDiagnosticsTableRows, a as parseJsonSchema, i as JsonSchemaDefinitionSchema, k as formatDoctorDiagnosticsJson, n as createMigrationConfig, r as generateDrizzleConfig, s as generateDrizzleSchema, t as collectDoctorDiagnostics } from "./doctor-collector-CGo5dgHm.mjs";
 
 export { JsonSchemaDefinitionSchema, buildDoctorDiagnostics, collectDoctorDiagnostics, createMigrationConfig, doctorDiagnosticsTableRows, formatDoctorDiagnosticsJson, generateDrizzleConfig, generateDrizzleSchema, parseJsonSchema };