1132 lines
43 KiB
JavaScript
1132 lines
43 KiB
JavaScript
// process/mineru-structured-translation.js
|
||
// MinerU 结构化翻译 - 基于 content_list.json 的批量翻译
|
||
|
||
/**
|
||
* MinerU 结构化翻译管理器
|
||
* 核心功能：
|
||
* 1. 从 content_list.json 提取可翻译内容并分批（10个/批）
|
||
* 2. 构建批量翻译提示词（复用现有的术语库和提示词池机制）
|
||
* 3. 执行批量翻译并保留格式元数据
|
||
*/
|
||
class MinerUStructuredTranslation {
|
||
constructor() {
|
||
this.BATCH_SIZE = 10; // 每批处理的片段数量
|
||
this.MAX_RETRIES = 2; // 批次调用最大重试次数（指数退避）
|
||
this.RETRY_BASE_DELAY = 800; // 初始重试延迟(ms)
|
||
// 注意：不再使用 failedItems 数组，失败项由 main.js 从 translatedContentList 统一收集
|
||
}
|
||
|
||
/**
|
||
* 检查是否支持结构化翻译
|
||
* @param {Object} ocrResult - OCR 结果对象
|
||
* @returns {boolean}
|
||
*/
|
||
supportsStructuredTranslation(ocrResult) {
|
||
if (!ocrResult || !ocrResult.metadata) return false;
|
||
return ocrResult.metadata.engine === 'mineru' &&
|
||
ocrResult.metadata.contentListJson &&
|
||
ocrResult.metadata.supportsStructuredTranslation === true;
|
||
}
|
||
|
||
/**
|
||
* 提取可翻译内容
|
||
* @param {Array} contentList - content_list.json 数组
|
||
* @returns {Array} 可翻译内容数组
|
||
*/
|
||
extractTranslatableContent(contentList) {
|
||
if (!Array.isArray(contentList)) {
|
||
console.error('[MinerU Structured] contentList 不是数组');
|
||
return [];
|
||
}
|
||
|
||
return contentList.map((item, index) => {
|
||
const translatable = {
|
||
id: this.generateId(item, index),
|
||
type: item.type,
|
||
bbox: item.bbox,
|
||
page_idx: item.page_idx || 0,
|
||
originalItem: item // 保存原始项以便后续重建
|
||
};
|
||
|
||
// 根据类型提取需要翻译的字段
|
||
switch (item.type) {
|
||
case 'text':
|
||
translatable.text = item.text || item.content || '';
|
||
translatable.text_level = item.text_level;
|
||
break;
|
||
|
||
case 'image':
|
||
translatable.img_path = item.img_path || item.image_path || '';
|
||
translatable.image_caption = item.image_caption || [];
|
||
break;
|
||
|
||
case 'formula':
|
||
translatable.latex = item.latex || '';
|
||
// 公式不翻译，但需要保留
|
||
break;
|
||
|
||
case 'table':
|
||
translatable.table_caption = item.table_caption || '';
|
||
translatable.table_data = item.table_data || '';
|
||
// 表格数据不翻译，仅翻译标题
|
||
break;
|
||
|
||
default:
|
||
translatable.text = item.text || item.content || '';
|
||
}
|
||
|
||
return translatable;
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 分批处理内容
|
||
* @param {Array} content - 可翻译内容数组
|
||
* @returns {Array} 批次数组
|
||
*/
|
||
splitIntoBatches(content) {
|
||
if (!Array.isArray(content) || content.length === 0) {
|
||
return [];
|
||
}
|
||
|
||
const batches = [];
|
||
|
||
for (let i = 0; i < content.length; i += this.BATCH_SIZE) {
|
||
batches.push({
|
||
batchIndex: Math.floor(i / this.BATCH_SIZE),
|
||
startIndex: i,
|
||
endIndex: Math.min(i + this.BATCH_SIZE, content.length),
|
||
items: content.slice(i, i + this.BATCH_SIZE),
|
||
// 保留上一批的最后一项作为上下文（如果存在）
|
||
context: i > 0 ? content[i - 1] : null
|
||
});
|
||
}
|
||
|
||
return batches;
|
||
}
|
||
|
||
/**
|
||
* 构建批量翻译提示词
|
||
* @param {Object} batch - 批次数据
|
||
* @param {string} targetLang - 目标语言
|
||
* @param {string} baseSystemPrompt - 基础系统提示词（来自提示词池或默认）
|
||
* @param {string} baseUserPromptTemplate - 基础用户提示词模板
|
||
* @returns {Object} { systemPrompt, userPrompt }
|
||
*/
|
||
buildBatchTranslationPrompt(batch, targetLang, baseSystemPrompt = '', baseUserPromptTemplate = '') {
|
||
// 1. 构建上下文提示
|
||
let contextHint = '';
|
||
if (batch.context) {
|
||
const contextText = this.formatContextItem(batch.context);
|
||
if (contextText) {
|
||
contextHint = `\n【上文参考】：${contextText}\n`;
|
||
}
|
||
}
|
||
|
||
// 2. 构建结构化翻译规则
|
||
const structuredRules = `
|
||
|
||
【结构化翻译规则】：
|
||
1. 输入是 JSON 数组格式的文档片段（共 ${batch.items.length} 个片段）
|
||
2. 每个片段只包含必要字段：
|
||
- "id"（唯一标识符，必须保持不变）
|
||
- "type"（类型，必须保持不变）
|
||
- 需要翻译的字段（根据类型而定）
|
||
3. 翻译规则：
|
||
- type="text"：翻译 "text" 字段的内容
|
||
- type="image"：翻译 "image_caption" 数组中的内容
|
||
- type="table"：翻译 "table_caption" 字段的内容
|
||
- type="formula"：无需翻译，保持原样即可
|
||
4. 翻译要求：
|
||
- 术语保持一致（专有名词、学术术语等）
|
||
- 考虑上文内容（如有），确保术语和表述一致
|
||
- 保持段落间逻辑关系
|
||
5. **JSON 格式要求（极其重要）**：
|
||
- 字符串中的特殊字符必须正确转义：
|
||
* 双引号：使用 \\"
|
||
* 换行符：使用 \\n
|
||
* 制表符：使用 \\t
|
||
* 反斜杠：使用 \\\\
|
||
- 确保输出是**合法的 JSON 格式**，可以被 JSON.parse() 解析
|
||
6. **输出格式**：
|
||
- 返回翻译后的完整 JSON 数组，结构与输入完全一致
|
||
- 使用 JSON 代码块包裹：\`\`\`json\n...\n\`\`\`
|
||
- **id 和 type 字段必须与输入完全一致**`;
|
||
|
||
// 3. 合并系统提示词
|
||
const systemPrompt = (baseSystemPrompt || '你是一位专业的文档翻译助手。') +
|
||
contextHint +
|
||
structuredRules;
|
||
|
||
// 4. 构建用户提示词 - 只提取必要字段发送给AI
|
||
// 简化数据结构，减少token消耗和JSON解析错误
|
||
const simplifiedItems = batch.items.map(item => {
|
||
const simplified = {
|
||
id: item.id,
|
||
type: item.type
|
||
};
|
||
|
||
// 根据类型提取需要翻译的字段
|
||
if (item.type === 'text') {
|
||
simplified.text = item.text || '';
|
||
} else if (item.type === 'image' && Array.isArray(item.image_caption)) {
|
||
simplified.image_caption = item.image_caption;
|
||
} else if (item.type === 'table') {
|
||
if (item.table_caption) simplified.table_caption = item.table_caption;
|
||
}
|
||
// formula类型不需要翻译任何内容
|
||
|
||
return simplified;
|
||
});
|
||
|
||
const jsonContent = JSON.stringify(simplifiedItems, null, 2);
|
||
|
||
// 如果有用户提示词模板，使用它；否则使用默认模板
|
||
let userPrompt;
|
||
if (baseUserPromptTemplate && baseUserPromptTemplate.includes('${content}')) {
|
||
userPrompt = baseUserPromptTemplate
|
||
.replace(/\$\{targetLangName\}/g, targetLang)
|
||
.replace(/\$\{content\}/g, `以下是需要翻译的 JSON 数组：\n\n\`\`\`json\n${jsonContent}\n\`\`\``);
|
||
} else {
|
||
userPrompt = `请将以下结构化文档片段翻译成${targetLang}。
|
||
|
||
**待翻译内容（JSON 格式）**：
|
||
\`\`\`json
|
||
${jsonContent}
|
||
\`\`\`
|
||
|
||
请严格按照上述规则返回翻译后的 JSON 数组。`;
|
||
}
|
||
|
||
return { systemPrompt, userPrompt };
|
||
}
|
||
|
||
/**
|
||
* 格式化上下文项为文本
|
||
* @param {Object} contextItem
|
||
* @returns {string}
|
||
*/
|
||
formatContextItem(contextItem) {
|
||
if (!contextItem) return '';
|
||
|
||
switch (contextItem.type) {
|
||
case 'text':
|
||
return contextItem.text || '';
|
||
case 'image':
|
||
if (Array.isArray(contextItem.image_caption) && contextItem.image_caption.length > 0) {
|
||
return contextItem.image_caption.join(' ');
|
||
}
|
||
return '（图片）';
|
||
case 'table':
|
||
return contextItem.table_caption || '（表格）';
|
||
case 'formula':
|
||
return '（公式）';
|
||
default:
|
||
return '';
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 执行批量翻译
|
||
* @param {Array} batches - 分批后的内容
|
||
* @param {string} targetLang - 目标语言
|
||
* @param {string} model - 翻译模型
|
||
* @param {string} apiKey - API Key
|
||
* @param {Object} options - 额外选项
|
||
* @param {Function} onProgress - 进度回调
|
||
* @param {Function} acquireSlot - 获取并发槽位
|
||
* @param {Function} releaseSlot - 释放并发槽位
|
||
* @returns {Promise<Array>} 翻译后的完整内容数组
|
||
*/
|
||
async translateBatches(batches, targetLang, model, apiKey, options = {}, onProgress, acquireSlot, releaseSlot) {
|
||
const totalBatches = batches.length;
|
||
let completedCount = 0;
|
||
|
||
if (typeof addProgressLog === 'function') {
|
||
addProgressLog(`[结构化翻译] 开始翻译 ${totalBatches} 个批次（共 ${batches.reduce((sum, b) => sum + b.items.length, 0)} 个片段）`);
|
||
}
|
||
|
||
// 并发翻译所有批次
|
||
const translateBatch = async (batch, batchIndex) => {
|
||
const logContext = `[批次 ${batchIndex + 1}/${totalBatches}]`;
|
||
let boundPrompt = null; // 移到外层，以便 catch 块可以访问
|
||
let apiStartTime = 0; // 移到外层，以便 catch 块可以访问
|
||
|
||
// 获取并发槽位
|
||
if (typeof acquireSlot === 'function') {
|
||
await acquireSlot();
|
||
}
|
||
|
||
try {
|
||
// 1. 获取基础提示词（来自提示词池或默认）
|
||
let baseSystemPrompt = '';
|
||
let baseUserPromptTemplate = '';
|
||
|
||
if (typeof window !== 'undefined' && window.promptPoolUI) {
|
||
const poolPrompt = window.promptPoolUI.getPromptForTranslation();
|
||
if (poolPrompt && poolPrompt.id && poolPrompt.systemPrompt && poolPrompt.userPromptTemplate) {
|
||
baseSystemPrompt = poolPrompt.systemPrompt;
|
||
baseUserPromptTemplate = poolPrompt.userPromptTemplate;
|
||
boundPrompt = poolPrompt;
|
||
|
||
// 记录到提示词池（用于统计和监控）
|
||
if (typeof window.translationPromptPool !== 'undefined' && typeof window.translationPromptPool.enqueueRequest === 'function') {
|
||
const requestId = `req_structured_${Date.now()}_${Math.random().toString(36).slice(2,8)}_b${batchIndex}`;
|
||
window.translationPromptPool.enqueueRequest(poolPrompt.id, { requestId, model: model });
|
||
}
|
||
|
||
// 界面日志显示
|
||
if (typeof addProgressLog === 'function') {
|
||
addProgressLog(`${logContext} 使用提示词池: ${poolPrompt.name || poolPrompt.id}`);
|
||
}
|
||
console.log(`${logContext} 使用提示词池的提示词:`, poolPrompt.id);
|
||
}
|
||
}
|
||
|
||
// 如果没有提示词池，使用内置模板
|
||
if (!baseSystemPrompt && typeof getBuiltInPrompts === 'function') {
|
||
const prompts = getBuiltInPrompts(targetLang);
|
||
baseSystemPrompt = prompts.systemPrompt;
|
||
baseUserPromptTemplate = prompts.userPromptTemplate;
|
||
}
|
||
|
||
// 2. 构建批量翻译提示词
|
||
const { systemPrompt, userPrompt } = this.buildBatchTranslationPrompt(
|
||
batch,
|
||
targetLang,
|
||
baseSystemPrompt,
|
||
baseUserPromptTemplate
|
||
);
|
||
|
||
// 3. 注入术语库（如果启用）
|
||
let finalSystemPrompt = systemPrompt;
|
||
try {
|
||
const settings = (typeof loadSettings === 'function') ? loadSettings() : {};
|
||
if (settings.enableGlossary && typeof getGlossaryMatchesForText === 'function') {
|
||
// 合并所有批次项的文本进行术语匹配
|
||
const batchText = batch.items.map(item => {
|
||
if (item.type === 'text') return item.text || '';
|
||
if (item.type === 'image' && Array.isArray(item.image_caption)) {
|
||
return item.image_caption.join(' ');
|
||
}
|
||
if (item.type === 'table') return item.table_caption || '';
|
||
return '';
|
||
}).filter(Boolean).join('\n');
|
||
|
||
const matches = getGlossaryMatchesForText(batchText);
|
||
if (matches && matches.length > 0) {
|
||
const instruction = (typeof buildGlossaryInstruction === 'function')
|
||
? buildGlossaryInstruction(matches, targetLang)
|
||
: '';
|
||
if (instruction) {
|
||
finalSystemPrompt += '\n\n' + instruction;
|
||
if (typeof addProgressLog === 'function') {
|
||
const names = matches.slice(0, 3).map(m => m.term).join(', ');
|
||
addProgressLog(`${logContext} 命中术语库 ${matches.length} 条：${names}${matches.length > 3 ? '...' : ''}`);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
} catch (e) {
|
||
console.warn(`${logContext} 术语库注入失败:`, e);
|
||
}
|
||
|
||
// 4. 调用翻译 API（带重试机制）
|
||
if (typeof addProgressLog === 'function') {
|
||
addProgressLog(`${logContext} 正在翻译 ${batch.items.length} 个片段...`);
|
||
}
|
||
|
||
let lastErr = null;
|
||
let translatedItems = null;
|
||
const maxRetries = options.maxRetries != null ? options.maxRetries : this.MAX_RETRIES;
|
||
const baseDelay = options.retryDelay != null ? options.retryDelay : this.RETRY_BASE_DELAY;
|
||
apiStartTime = Date.now(); // 更新开始时间
|
||
|
||
for (let attempt = 0; attempt <= maxRetries; attempt++) {
|
||
try {
|
||
const translatedJson = await this.callTranslationAPI(
|
||
finalSystemPrompt,
|
||
userPrompt,
|
||
model,
|
||
apiKey,
|
||
options
|
||
);
|
||
const parsed = this.parseTranslationResponse(translatedJson);
|
||
if (!this.validateTranslation(batch.items, parsed)) {
|
||
throw new Error('翻译结果结构不匹配');
|
||
}
|
||
translatedItems = parsed;
|
||
|
||
// 记录提示词池使用成功
|
||
if (boundPrompt && typeof window.translationPromptPool !== 'undefined' && typeof window.translationPromptPool.recordPromptUsage === 'function') {
|
||
window.translationPromptPool.recordPromptUsage(
|
||
boundPrompt.id,
|
||
true,
|
||
Date.now() - apiStartTime,
|
||
null,
|
||
{ model: model, endpoint: 'structured-translation' }
|
||
);
|
||
}
|
||
|
||
break; // 成功
|
||
} catch (e) {
|
||
lastErr = e;
|
||
if (attempt < maxRetries) {
|
||
const delay = Math.min(baseDelay * Math.pow(2, attempt), 10000);
|
||
console.warn(`${logContext} 翻译失败（第 ${attempt + 1}/${maxRetries + 1} 次），${delay}ms 后重试:`, e?.message || e);
|
||
await this.delay(delay);
|
||
continue;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!translatedItems) {
|
||
// 全批失败：标记该批所有项失败并返回原文
|
||
const failed = batch.items.map((it, idx) => {
|
||
const clone = { ...it, failed: true };
|
||
// 不在这里添加到 failedItems，让 main.js 统一收集
|
||
return clone;
|
||
});
|
||
|
||
// 记录提示词池使用失败
|
||
if (boundPrompt && typeof window.translationPromptPool !== 'undefined' && typeof window.translationPromptPool.recordPromptUsage === 'function') {
|
||
window.translationPromptPool.recordPromptUsage(
|
||
boundPrompt.id,
|
||
false,
|
||
Date.now() - apiStartTime,
|
||
lastErr?.message || '未知错误',
|
||
{ model: model, endpoint: 'structured-translation' }
|
||
);
|
||
}
|
||
|
||
if (typeof addProgressLog === 'function') {
|
||
addProgressLog(`${logContext} 翻译失败：${lastErr?.message || '未知错误'}（已达最大重试次数）`);
|
||
}
|
||
return { batchIndex, items: failed };
|
||
}
|
||
|
||
// 5. 细粒度失败标记 + 合并翻译结果到原始对象
|
||
// 关键：保留原始对象的所有字段（bbox、page_idx、originalItem等），只更新翻译字段
|
||
const markedItems = translatedItems.map((it, idx) => {
|
||
const orig = batch.items[idx];
|
||
let isFailed = false;
|
||
let failureReason = ''; // 记录失败原因
|
||
|
||
// 先复制原始完整对象，保留所有元数据（bbox、page_idx等，用于定位）
|
||
const out = { ...orig };
|
||
|
||
if (orig && it) {
|
||
if (orig.type === 'text') {
|
||
const a = this._normalizeText(orig.text);
|
||
const b = this._normalizeText(it.text);
|
||
|
||
// 只有原文不为空但译文为空时才标记为失败（译文与原文相同是正常行为）
|
||
if (!b && !!a) {
|
||
isFailed = true;
|
||
failureReason = 'empty'; // 空译文，需要自动重试
|
||
|
||
// 调试日志：记录失败判定详情
|
||
console.log(`[结构化翻译] 项目 ${idx} 判定为失败: 译文为空`, {
|
||
原文前50字: a.substring(0, 50),
|
||
原文长度: a.length
|
||
});
|
||
} else if (b === a) {
|
||
// 译文与原文相同，记录日志但不标记为失败（可能是专有名词、公式等）
|
||
console.log(`[结构化翻译] 项目 ${idx} 译文与原文相同（正常）`, {
|
||
文本前50字: a.substring(0, 50)
|
||
});
|
||
}
|
||
|
||
// 更新翻译后的文本
|
||
if (!isFailed && it.text !== undefined) {
|
||
out.text = it.text;
|
||
}
|
||
} else if (orig.type === 'image') {
|
||
const a = this._normalizeText(Array.isArray(orig.image_caption) ? orig.image_caption.join(' ') : orig.image_caption);
|
||
const b = this._normalizeText(Array.isArray(it.image_caption) ? it.image_caption.join(' ') : it.image_caption);
|
||
|
||
// 只有译文为空时才标记为失败
|
||
if (!b && !!a) {
|
||
isFailed = true;
|
||
failureReason = 'empty';
|
||
console.log(`[结构化翻译] 项目 ${idx} (image) 判定为失败: 图片说明为空`);
|
||
}
|
||
|
||
// 更新翻译后的图片说明
|
||
if (!isFailed && it.image_caption !== undefined) {
|
||
out.image_caption = it.image_caption;
|
||
}
|
||
} else if (orig.type === 'table') {
|
||
const a = this._normalizeText(orig.table_caption);
|
||
const b = this._normalizeText(it.table_caption);
|
||
|
||
// 只有译文为空时才标记为失败
|
||
if (!b && !!a) {
|
||
isFailed = true;
|
||
failureReason = 'empty';
|
||
console.log(`[结构化翻译] 项目 ${idx} (table) 判定为失败: 表格标题为空`);
|
||
}
|
||
|
||
// 更新翻译后的表格标题
|
||
if (!isFailed && it.table_caption !== undefined) {
|
||
out.table_caption = it.table_caption;
|
||
}
|
||
} else if (orig.type === 'formula') {
|
||
isFailed = false; // 公式不需要翻译
|
||
}
|
||
}
|
||
|
||
if (isFailed) {
|
||
out.failed = true;
|
||
out.failureReason = failureReason; // 保存失败原因
|
||
} else {
|
||
// 翻译成功：明确移除 failed 标记（如果原来有的话）
|
||
delete out.failed;
|
||
delete out.failureReason;
|
||
}
|
||
return out;
|
||
});
|
||
|
||
// 6. 对"译文为空"的项进行单独重试（最多2次）
|
||
const emptyFailedIndices = [];
|
||
markedItems.forEach((item, idx) => {
|
||
if (item.failed && item.failureReason === 'empty') {
|
||
emptyFailedIndices.push(idx);
|
||
}
|
||
});
|
||
|
||
if (emptyFailedIndices.length > 0) {
|
||
console.log(`[结构化翻译] 批次 ${batchIndex + 1}: 发现 ${emptyFailedIndices.length} 个空译文项，开始单独重试...`);
|
||
|
||
for (const idx of emptyFailedIndices) {
|
||
const item = markedItems[idx];
|
||
const origItem = batch.items[idx];
|
||
let retrySuccess = false;
|
||
|
||
// 最多重试2次
|
||
for (let retryAttempt = 1; retryAttempt <= 2 && !retrySuccess; retryAttempt++) {
|
||
try {
|
||
console.log(`[结构化翻译] 重试项目 ${idx} (第 ${retryAttempt} 次)...`);
|
||
|
||
// 构建单条翻译的简化数据
|
||
const singleItem = {
|
||
id: origItem.id,
|
||
type: origItem.type
|
||
};
|
||
|
||
if (origItem.type === 'text') {
|
||
singleItem.text = origItem.text || '';
|
||
} else if (origItem.type === 'image' && Array.isArray(origItem.image_caption)) {
|
||
singleItem.image_caption = origItem.image_caption;
|
||
} else if (origItem.type === 'table') {
|
||
if (origItem.table_caption) singleItem.table_caption = origItem.table_caption;
|
||
}
|
||
|
||
// 构建单条翻译提示词（使用与批次翻译相同的 prompt 构建逻辑）
|
||
const singleBatch = { items: [singleItem] };
|
||
const { systemPrompt: retrySysPrompt, userPrompt: retryUserPrompt } = this.buildBatchTranslationPrompt(
|
||
singleBatch,
|
||
targetLang,
|
||
baseSystemPrompt,
|
||
baseUserPromptTemplate
|
||
);
|
||
|
||
// 调用API翻译单条
|
||
const singleResponse = await this.callTranslationAPI(
|
||
retrySysPrompt,
|
||
retryUserPrompt,
|
||
model,
|
||
apiKey,
|
||
options
|
||
);
|
||
|
||
// 解析单条翻译结果
|
||
const singleTranslated = this.parseTranslationResponse(singleResponse);
|
||
|
||
if (singleTranslated && singleTranslated.length > 0) {
|
||
const translatedItem = singleTranslated[0];
|
||
|
||
// 检查是否真的翻译成功了
|
||
let isStillEmpty = false;
|
||
if (origItem.type === 'text') {
|
||
const b = this._normalizeText(translatedItem.text);
|
||
isStillEmpty = !b;
|
||
} else if (origItem.type === 'image') {
|
||
const b = this._normalizeText(Array.isArray(translatedItem.image_caption) ? translatedItem.image_caption.join(' ') : translatedItem.image_caption);
|
||
isStillEmpty = !b;
|
||
} else if (origItem.type === 'table') {
|
||
const b = this._normalizeText(translatedItem.table_caption);
|
||
isStillEmpty = !b;
|
||
}
|
||
|
||
if (!isStillEmpty) {
|
||
// 重试成功！更新 markedItems
|
||
if (origItem.type === 'text') {
|
||
markedItems[idx].text = translatedItem.text;
|
||
} else if (origItem.type === 'image') {
|
||
markedItems[idx].image_caption = translatedItem.image_caption;
|
||
} else if (origItem.type === 'table') {
|
||
markedItems[idx].table_caption = translatedItem.table_caption;
|
||
}
|
||
|
||
delete markedItems[idx].failed;
|
||
delete markedItems[idx].failureReason;
|
||
retrySuccess = true;
|
||
|
||
console.log(`[结构化翻译] ✓ 项目 ${idx} 重试成功`);
|
||
|
||
if (typeof addProgressLog === 'function') {
|
||
addProgressLog(`${logContext} 项目 ${idx} 重试成功`);
|
||
}
|
||
} else {
|
||
console.warn(`[结构化翻译] 项目 ${idx} 第 ${retryAttempt} 次重试仍为空`);
|
||
}
|
||
}
|
||
|
||
// 如果还有下一次重试，等待一下
|
||
if (!retrySuccess && retryAttempt < 2) {
|
||
await this.delay(500);
|
||
}
|
||
|
||
} catch (retryError) {
|
||
console.error(`[结构化翻译] 项目 ${idx} 第 ${retryAttempt} 次重试失败:`, retryError);
|
||
}
|
||
}
|
||
|
||
if (!retrySuccess) {
|
||
console.warn(`[结构化翻译] ✗ 项目 ${idx} 重试 2 次后仍然失败`);
|
||
if (typeof addProgressLog === 'function') {
|
||
addProgressLog(`${logContext} 项目 ${idx} 重试失败`);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 7. 统计本批次失败情况（重试后）
|
||
const batchFailedCount = markedItems.filter(item => item.failed === true).length;
|
||
const batchSuccessCount = markedItems.length - batchFailedCount;
|
||
|
||
console.log(`[结构化翻译] 批次 ${batchIndex + 1} 完成: ${batchSuccessCount}/${markedItems.length} 成功, ${batchFailedCount} 失败`);
|
||
|
||
// 8. 更新进度
|
||
completedCount++;
|
||
onProgress?.({
|
||
current: completedCount,
|
||
total: totalBatches,
|
||
percentage: Math.floor((completedCount / totalBatches) * 100),
|
||
message: `已完成 ${completedCount}/${totalBatches} 批次 (${batchSuccessCount}/${markedItems.length} 成功)`
|
||
});
|
||
|
||
if (typeof addProgressLog === 'function') {
|
||
addProgressLog(`${logContext} 翻译完成 (${batchSuccessCount}/${markedItems.length} 成功)`);
|
||
}
|
||
|
||
return { batchIndex, items: markedItems };
|
||
|
||
} catch (error) {
|
||
console.error(`${logContext} 翻译失败:`, error);
|
||
|
||
// 记录提示词池使用失败（捕获未预期的异常）
|
||
if (boundPrompt && typeof window.translationPromptPool !== 'undefined' && typeof window.translationPromptPool.recordPromptUsage === 'function') {
|
||
const duration = apiStartTime > 0 ? (Date.now() - apiStartTime) : 0;
|
||
window.translationPromptPool.recordPromptUsage(
|
||
boundPrompt.id,
|
||
false,
|
||
duration,
|
||
error?.message || String(error),
|
||
{ model: model, endpoint: 'structured-translation' }
|
||
);
|
||
}
|
||
|
||
if (typeof addProgressLog === 'function') {
|
||
addProgressLog(`${logContext} 翻译失败: ${error.message}，将使用原文`);
|
||
}
|
||
// 回退：使用原文并标记失败
|
||
const failed = batch.items.map((it, idx) => {
|
||
const clone = { ...it, failed: true };
|
||
// 不在这里添加到 failedItems，让 main.js 统一收集
|
||
return clone;
|
||
});
|
||
return { batchIndex, items: failed };
|
||
} finally {
|
||
// 释放并发槽位
|
||
if (typeof releaseSlot === 'function') {
|
||
releaseSlot();
|
||
}
|
||
}
|
||
};
|
||
|
||
// 并发执行所有批次翻译
|
||
const batchPromises = batches.map((batch, index) => translateBatch(batch, index));
|
||
const batchResults = await Promise.all(batchPromises);
|
||
|
||
// 按批次索引排序，确保结果顺序正确
|
||
batchResults.sort((a, b) => a.batchIndex - b.batchIndex);
|
||
|
||
// 合并所有翻译结果
|
||
const results = [];
|
||
for (const result of batchResults) {
|
||
results.push(...result.items);
|
||
}
|
||
|
||
// 统计整体翻译情况
|
||
const totalItems = results.length;
|
||
const failedItems = results.filter(item => item.failed === true);
|
||
const failedCount = failedItems.length;
|
||
const successCount = totalItems - failedCount;
|
||
|
||
console.log(`[结构化翻译] 全部完成: ${successCount}/${totalItems} 成功, ${failedCount} 失败`);
|
||
|
||
if (failedCount > 0) {
|
||
console.warn(`[结构化翻译] 失败项索引:`, failedItems.map((item, idx) => {
|
||
const originalIdx = results.indexOf(item);
|
||
return `#${originalIdx} (${item.type})`;
|
||
}).join(', '));
|
||
}
|
||
|
||
if (typeof addProgressLog === 'function') {
|
||
addProgressLog(`结构化翻译完成: ${successCount}/${totalItems} 成功${failedCount > 0 ? `, ${failedCount} 失败` : ''}`);
|
||
}
|
||
|
||
return results;
|
||
}
|
||
|
||
/**
|
||
* 调用翻译 API
|
||
* @param {string} systemPrompt
|
||
* @param {string} userPrompt
|
||
* @param {string} model
|
||
* @param {string} apiKey
|
||
* @param {Object} options
|
||
* @returns {Promise<string>}
|
||
*/
|
||
async callTranslationAPI(systemPrompt, userPrompt, model, apiKey, options = {}) {
|
||
const settings = typeof loadSettings === 'function' ? loadSettings() : {};
|
||
const temperature = (settings.customModelSettings && settings.customModelSettings.temperature) || 0.5;
|
||
const maxTokens = (settings.customModelSettings && settings.customModelSettings.max_tokens) || 8000;
|
||
|
||
console.log('[MinerU Structured] callTranslationAPI 调用参数:', {
|
||
model,
|
||
hasApiKey: !!apiKey,
|
||
useBackendProxy: options.useBackendProxy,
|
||
options
|
||
});
|
||
|
||
// 后端代理模式 - API Key 由后端管理
|
||
if (options.useBackendProxy) {
|
||
const proxyBase = options.proxyBase ||
|
||
(typeof window !== 'undefined' && window.ProxyConfig ? window.ProxyConfig.getProxyUrl() : null) ||
|
||
(typeof window !== 'undefined' && window.PBX_PROXY_BASE_URL ? window.PBX_PROXY_BASE_URL : null) ||
|
||
'http://localhost:3456';
|
||
const provider = options.provider || 'aliyun';
|
||
|
||
// 后端代理端点映射
|
||
const providerEndpoints = {
|
||
'aliyun': `${proxyBase}/api/llm/aliyun/v1/chat/completions`,
|
||
'tongyi': `${proxyBase}/api/llm/tongyi/v1/chat/completions`,
|
||
'deepseek': `${proxyBase}/api/llm/deepseek/v1/chat/completions`,
|
||
'openai': `${proxyBase}/api/llm/openai/v1/chat/completions`,
|
||
'mistral': `${proxyBase}/api/llm/mistral/v1/chat/completions`,
|
||
'zhipu': `${proxyBase}/api/llm/zhipu/v4/chat/completions`,
|
||
'anthropic': `${proxyBase}/api/llm/anthropic/v1/messages`,
|
||
'gemini': `${proxyBase}/api/llm/gemini/v1beta/models/gemini-pro:generateContent`
|
||
};
|
||
|
||
const endpoint = providerEndpoints[provider] || providerEndpoints['aliyun'];
|
||
|
||
// 获取模型 ID
|
||
let modelId = 'qwen-turbo-latest';
|
||
try {
|
||
const modelConfig = typeof loadModelConfig === 'function' ? loadModelConfig(provider) : null;
|
||
if (modelConfig && (modelConfig.preferredModelId || modelConfig.modelId)) {
|
||
modelId = modelConfig.preferredModelId || modelConfig.modelId;
|
||
}
|
||
} catch (e) {
|
||
console.warn('[MinerU Structured] 加载模型配置失败，使用默认模型:', e);
|
||
}
|
||
|
||
const requestBody = {
|
||
model: modelId,
|
||
messages: [
|
||
{ role: "system", content: systemPrompt },
|
||
{ role: "user", content: userPrompt }
|
||
],
|
||
temperature,
|
||
max_tokens: maxTokens
|
||
};
|
||
|
||
console.log('[MinerU Structured] 后端代理模式:', { endpoint, provider, modelId });
|
||
|
||
try {
|
||
const response = await fetch(endpoint, {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify(requestBody)
|
||
});
|
||
|
||
if (!response.ok) {
|
||
const errorText = await response.text();
|
||
throw new Error(`翻译 API 请求失败 (${response.status}): ${errorText}`);
|
||
}
|
||
|
||
const data = await response.json();
|
||
const result = data?.choices?.[0]?.message?.content;
|
||
|
||
if (!result) {
|
||
throw new Error('翻译 API 返回空结果');
|
||
}
|
||
|
||
// 清理指令块
|
||
return this._stripInstructionBlocks(result);
|
||
|
||
} catch (error) {
|
||
console.error('[MinerU Structured] 后端代理请求失败:', error);
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
// 原有逻辑 - 前端直接调用（需要 API Key）
|
||
if (typeof processModule === 'undefined' ||
|
||
typeof processModule.buildPredefinedApiConfig !== 'function' ||
|
||
typeof processModule.buildCustomApiConfig !== 'function') {
|
||
throw new Error('translation.js 尚未加载');
|
||
}
|
||
|
||
if (typeof callTranslationApi !== 'function') {
|
||
throw new Error('callTranslationApi 函数不可用');
|
||
}
|
||
|
||
// 构建 API 配置
|
||
let apiConfig;
|
||
if (model === 'custom') {
|
||
const modelConfig = options.modelConfig;
|
||
|
||
// 修复：支持 apiBaseUrl 或 apiEndpoint
|
||
const apiEndpoint = modelConfig && (modelConfig.apiEndpoint || modelConfig.apiBaseUrl);
|
||
const modelId = modelConfig && modelConfig.modelId;
|
||
|
||
console.log('[MinerU Structured] 自定义模型配置检查:', {
|
||
hasModelConfig: !!modelConfig,
|
||
hasApiEndpoint: !!apiEndpoint,
|
||
hasModelId: !!modelId,
|
||
modelConfig
|
||
});
|
||
|
||
if (!modelConfig || !apiEndpoint || !modelId) {
|
||
console.error('[MinerU Structured] 自定义模型配置不完整!', {
|
||
modelConfig,
|
||
options,
|
||
apiEndpoint,
|
||
modelId
|
||
});
|
||
throw new Error('自定义模型配置不完整');
|
||
}
|
||
apiConfig = processModule.buildCustomApiConfig(
|
||
apiKey,
|
||
apiEndpoint,
|
||
modelId,
|
||
modelConfig.requestFormat || 'openai',
|
||
modelConfig.temperature !== undefined ? modelConfig.temperature : 0.5,
|
||
modelConfig.max_tokens !== undefined ? modelConfig.max_tokens : 8000,
|
||
{ endpointMode: modelConfig.endpointMode || 'auto' }
|
||
);
|
||
} else {
|
||
// 预设模型 - 从 translation.js 获取配置
|
||
// 简化：仅支持常用模型
|
||
// 前端发出的请求源头
|
||
const proxyUrl = (typeof window !== 'undefined' && window.ProxyConfig)
|
||
? window.ProxyConfig.getProxyUrl()
|
||
: (window.PBX_PROXY_BASE_URL || 'http://localhost:3456');
|
||
const predefinedConfigs = {
|
||
'proxy': {
|
||
endpoint: `${proxyUrl}/api/llm/aliyun/v1/chat/completions`,
|
||
modelName: '通义百炼 (via local proxy)',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
bodyBuilder: (sys, user) => ({
|
||
model: 'qwen-turbo-latest',
|
||
messages: [{ role: "system", content: sys }, { role: "user", content: user }],
|
||
temperature,
|
||
max_tokens: maxTokens
|
||
}),
|
||
responseExtractor: (data) => data?.choices?.[0]?.message?.content
|
||
},
|
||
'mistral': {
|
||
endpoint: 'https://api.mistral.ai/v1/chat/completions',
|
||
modelName: 'Mistral Large',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
bodyBuilder: (sys, user) => ({
|
||
model: 'mistral-large-latest',
|
||
messages: [{ role: "system", content: sys }, { role: "user", content: user }],
|
||
temperature,
|
||
max_tokens: maxTokens
|
||
}),
|
||
responseExtractor: (data) => data?.choices?.[0]?.message?.content
|
||
}
|
||
};
|
||
|
||
if (!predefinedConfigs[model]) {
|
||
throw new Error(`不支持的翻译模型: ${model}`);
|
||
}
|
||
|
||
apiConfig = processModule.buildPredefinedApiConfig(predefinedConfigs[model], apiKey);
|
||
}
|
||
|
||
// 构建请求体
|
||
const requestBody = apiConfig.bodyBuilder
|
||
? apiConfig.bodyBuilder(systemPrompt, userPrompt)
|
||
: {
|
||
model: apiConfig.modelName,
|
||
messages: [
|
||
{ role: "system", content: systemPrompt },
|
||
{ role: "user", content: userPrompt }
|
||
]
|
||
};
|
||
|
||
// 调用API
|
||
let result = await callTranslationApi(apiConfig, requestBody);
|
||
|
||
// 清理指令块（防止系统提示词泄露到翻译结果中）
|
||
return this._stripInstructionBlocks(result);
|
||
}
|
||
|
||
/**
|
||
* 清理指令块
|
||
* @param {string} result
|
||
* @returns {string}
|
||
*/
|
||
_stripInstructionBlocks(result) {
|
||
if (typeof stripInstructionBlocks === 'function') {
|
||
return stripInstructionBlocks(result);
|
||
} else if (typeof processModule !== 'undefined' && typeof processModule.stripInstructionBlocks === 'function') {
|
||
return processModule.stripInstructionBlocks(result);
|
||
} else {
|
||
// 回退：手动清理
|
||
if (typeof result === 'string') {
|
||
return result.replace(/\s*\[\[PBX_INSTR_START\]\][\s\S]*?\[\[PBX_INSTR_END\]\]\s*/gi, '').trim();
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 修复JSON字符串值中的未转义换行符
|
||
* @param {string} jsonStr
|
||
* @returns {string}
|
||
*/
|
||
_fixUnescapedNewlinesInJsonStrings(jsonStr) {
|
||
let result = '';
|
||
let inString = false;
|
||
let escapeNext = false;
|
||
|
||
for (let i = 0; i < jsonStr.length; i++) {
|
||
const char = jsonStr[i];
|
||
|
||
if (escapeNext) {
|
||
// 当前字符被转义，直接添加
|
||
result += char;
|
||
escapeNext = false;
|
||
continue;
|
||
}
|
||
|
||
if (char === '\\') {
|
||
// 下一个字符将被转义
|
||
result += char;
|
||
escapeNext = true;
|
||
continue;
|
||
}
|
||
|
||
if (char === '"') {
|
||
// 切换字符串状态
|
||
inString = !inString;
|
||
result += char;
|
||
continue;
|
||
}
|
||
|
||
if (inString && char === '\n') {
|
||
// 在字符串内部遇到换行符，转义为 \\n
|
||
result += '\\n';
|
||
continue;
|
||
}
|
||
|
||
// 其他字符直接添加
|
||
result += char;
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 解析翻译响应（提取 JSON）
|
||
* @param {string} response
|
||
* @returns {Array}
|
||
*/
|
||
parseTranslationResponse(response) {
|
||
if (!response || typeof response !== 'string') {
|
||
throw new Error('翻译响应为空或不是文本');
|
||
}
|
||
|
||
// 1) 优先提取代码块（兼容 ```json / ``` JSON / ``` 任意）
|
||
let raw = null;
|
||
let m = response.match(/```\s*json\s*([\s\S]*?)\s*```/i);
|
||
if (!m) m = response.match(/```\s*([\s\S]*?)\s*```/);
|
||
if (m) raw = m[1]; else raw = response;
|
||
|
||
// 2) 去掉前后噪声，裁剪到 {..} 或 [..]
|
||
const startObj = raw.indexOf('{');
|
||
const startArr = raw.indexOf('[');
|
||
let start = -1;
|
||
if (startObj === -1 && startArr === -1) start = -1;
|
||
else if (startObj === -1) start = startArr; else if (startArr === -1) start = startObj; else start = Math.min(startObj, startArr);
|
||
if (start > 0) raw = raw.slice(start);
|
||
const endObj = raw.lastIndexOf('}');
|
||
const endArr = raw.lastIndexOf(']');
|
||
let end = Math.max(endObj, endArr);
|
||
if (end >= 0) raw = raw.slice(0, end + 1);
|
||
|
||
// 3) 规范化：替换花引号、清理无效转义、移除尾随逗号
|
||
let cleaned = raw
|
||
.replace(/[""]/g, '"') // 中文引号
|
||
.replace(/,\s*([}\]])/g, '$1') // 尾随逗号
|
||
.replace(/\r\n/g, '\n') // 统一换行符
|
||
.replace(/\r/g, '\n');
|
||
|
||
// 4) 修复字符串值中的未转义换行符
|
||
// 这是导致 "Unterminated string" 错误的主要原因
|
||
// 需要在JSON字符串值内部将真实换行符转义为 \\n
|
||
cleaned = this._fixUnescapedNewlinesInJsonStrings(cleaned);
|
||
|
||
// 5) 修复常见的无效转义（但保留合法的转义序列）
|
||
// 合法的 JSON 转义：\" \\ \/ \b \f \n \r \t \uXXXX
|
||
// 先处理已经双反斜杠的情况（避免重复转义）
|
||
const placeholder = '\u0000ESCAPED_BACKSLASH\u0000';
|
||
cleaned = cleaned.replace(/\\\\/g, placeholder);
|
||
|
||
// 然后处理无效的单反斜杠转义（除了合法的 JSON 转义）
|
||
cleaned = cleaned.replace(/\\(?!["\\\/bfnrtu]|u[0-9a-fA-F]{4})/g, '\\\\');
|
||
|
||
// 恢复占位符
|
||
cleaned = cleaned.replace(new RegExp(placeholder, 'g'), '\\\\');
|
||
|
||
// 5) 尝试解析
|
||
try {
|
||
return JSON.parse(cleaned);
|
||
} catch (e1) {
|
||
console.error('JSON 解析失败（清理后）:', e1);
|
||
console.error('清理后的内容（前500字符）:', cleaned.substring(0, 500));
|
||
|
||
// 最后尝试：更激进的修复
|
||
try {
|
||
// 把所有单反斜杠都转义（可能会破坏一些内容，但至少能解析）
|
||
const aggressive = cleaned.replace(/\\/g, '\\\\');
|
||
return JSON.parse(aggressive);
|
||
} catch (e2) {
|
||
console.error('激进清理也失败:', e2);
|
||
throw new Error('无法解析翻译结果为 JSON 格式');
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 验证翻译结果
|
||
* @param {Array} original
|
||
* @param {Array} translated
|
||
* @returns {boolean}
|
||
*/
|
||
validateTranslation(original, translated) {
|
||
if (!Array.isArray(original) || !Array.isArray(translated)) {
|
||
console.error('[MinerU Structured] 验证失败：输入不是数组');
|
||
return false;
|
||
}
|
||
|
||
if (original.length !== translated.length) {
|
||
console.error('[MinerU Structured] 验证失败：长度不一致', original.length, translated.length);
|
||
return false;
|
||
}
|
||
|
||
// 验证每个元素的关键字段
|
||
// 注意：由于发送给AI的是简化数据（只有id、type和翻译字段），
|
||
// AI返回的也只有这些字段，不包含page_idx、bbox等元数据
|
||
for (let i = 0; i < original.length; i++) {
|
||
const orig = original[i];
|
||
const trans = translated[i];
|
||
|
||
// 验证 id 是否匹配（用于正确对应原始项）
|
||
if (orig.id !== trans.id) {
|
||
console.error(`[MinerU Structured] 验证失败：索引 ${i} 的 id 不匹配`, orig.id, trans.id);
|
||
return false;
|
||
}
|
||
|
||
// 验证 type 是否匹配
|
||
if (orig.type !== trans.type) {
|
||
console.error(`[MinerU Structured] 验证失败：索引 ${i} 的 type 不匹配`, orig.type, trans.type);
|
||
return false;
|
||
}
|
||
|
||
// 不再验证 page_idx、bbox 等元数据字段，因为AI返回的简化数据中不包含这些
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 提取用于重试展示的文本
|
||
*/
|
||
extractItemText(item) {
|
||
if (!item) return '';
|
||
if (item.type === 'text') return item.text || '';
|
||
if (item.type === 'image') return Array.isArray(item.image_caption) ? item.image_caption.join(' ') : '';
|
||
if (item.type === 'table') return item.table_caption || '';
|
||
return '';
|
||
}
|
||
|
||
_normalizeText(v) {
|
||
if (v == null) return '';
|
||
try {
|
||
if (Array.isArray(v)) return v.join(' ').trim();
|
||
if (typeof v === 'string') return v.trim();
|
||
return String(v).trim();
|
||
} catch (_) { return ''; }
|
||
}
|
||
|
||
/**
|
||
* 生成唯一 ID
|
||
* @param {Object} item
|
||
* @param {number} index
|
||
* @returns {string}
|
||
*/
|
||
generateId(item, index) {
|
||
const page = item.page_idx || 0;
|
||
const bbox = item.bbox ? item.bbox.join('_') : 'nobbox';
|
||
return `p${page}_${bbox}_${index}`;
|
||
}
|
||
|
||
/**
|
||
* 延迟函数
|
||
* @param {number} ms
|
||
* @returns {Promise}
|
||
*/
|
||
delay(ms) {
|
||
return new Promise(resolve => setTimeout(resolve, ms));
|
||
}
|
||
|
||
/**
|
||
* 重建 Markdown（可选功能，暂不实现）
|
||
* 如果需要基于翻译后的 JSON 重新生成 Markdown，可在此实现
|
||
*/
|
||
rebuildMarkdown(translatedContent) {
|
||
// TODO: 实现 Markdown 重建逻辑
|
||
// 目前直接使用原始的 markdown，仅在元数据中保存翻译后的 JSON
|
||
return null;
|
||
}
|
||
}
|
||
|
||
// 导出到全局
|
||
if (typeof window !== 'undefined') {
|
||
window.MinerUStructuredTranslation = MinerUStructuredTranslation;
|
||
}
|
||
|
||
// 模块化导出
|
||
if (typeof processModule !== 'undefined') {
|
||
processModule.MinerUStructuredTranslation = MinerUStructuredTranslation;
|
||
}
|