878 lines
44 KiB
JavaScript
878 lines
44 KiB
JavaScript
// process/document.js
|
||
|
||
/**
|
||
* 将长文档分割为可翻译的块。
|
||
* 此函数旨在将 Markdown 文本按照指定的 token 限制进行智能分块，
|
||
* 以便适应大语言模型处理上下文长度的限制。
|
||
*
|
||
* 主要策略：
|
||
* 1. **Token 估算与初步判断**：
|
||
* - 使用 `estimateTokenCount` 估算整个文档的 token 数。
|
||
* - 如果文档未超过 token 限制的 1.1 倍，则不进行分割，直接返回原文作为一个块。
|
||
* 2. **行级初步分割**：
|
||
* - 遍历文本的每一行。
|
||
* - 跟踪当前块的 token 数和行内容。
|
||
* - 智能分割点选择：
|
||
* - 当 `currentTokenCount + lineTokens > tokenLimit` 且当前块已有一定内容 (`currentTokenCount > tokenLimit * 0.1`) 时，进行分割。
|
||
* - 在非代码块内，如果遇到一级或二级 Markdown 标题 (`#` 或 `##`)，并且当前块内容已超过限制的 50%，则在此标题前分割，以保持章节完整性。
|
||
* - 维护 `inCodeBlock` 状态，避免在代码块内部错误地根据标题分割。
|
||
* 3. **二次段落级分割（针对超大块）**：
|
||
* - 对初步分割产生的每个块进行检查。
|
||
* - 如果某个块的 token 数仍然超过限制的 1.1 倍，则调用 `splitByParagraphs` 对其进行更细致的段落级分割。
|
||
* 4. **日志记录**：在关键步骤通过 `addProgressLog` (如果可用) 输出日志，方便追踪分割过程。
|
||
*
|
||
* @param {string} markdown - 要分割的Markdown文本。
|
||
* @param {number} tokenLimit - 每块的最大token数。
|
||
* @param {string} [logContext=""] - 日志前缀，用于区分不同上下文的日志输出。
|
||
* @returns {Array<string>} 分割后的文本块数组。
|
||
*/
|
||
function splitMarkdownIntoChunks(markdown, tokenLimit, logContext = "") {
|
||
const estimatedTokens = estimateTokenCount(markdown);
|
||
if (typeof addProgressLog === "function") {
|
||
addProgressLog(`${logContext} 估算总 token 数: ~${estimatedTokens}, 分段限制: ${tokenLimit}`);
|
||
}
|
||
|
||
if (estimatedTokens <= tokenLimit * 1.1) {
|
||
if (typeof addProgressLog === "function") {
|
||
addProgressLog(`${logContext} 文档未超过大小限制，不进行分割。`);
|
||
}
|
||
return [markdown];
|
||
}
|
||
|
||
if (typeof addProgressLog === "function") {
|
||
addProgressLog(`${logContext} 文档超过大小限制，开始分割...`);
|
||
}
|
||
const lines = markdown.split('\n');
|
||
const chunks = [];
|
||
let currentChunkLines = [];
|
||
let currentTokenCount = 0;
|
||
let inCodeBlock = false;
|
||
const headingRegex = /^(#+)\s+.*/;
|
||
|
||
for (let i = 0; i < lines.length; i++) {
|
||
const line = lines[i];
|
||
const lineTokens = estimateTokenCount(line);
|
||
|
||
if (line.trim().startsWith('```')) {
|
||
inCodeBlock = !inCodeBlock;
|
||
}
|
||
|
||
let shouldSplit = false;
|
||
|
||
if (currentChunkLines.length > 0) {
|
||
if (currentTokenCount + lineTokens > tokenLimit) {
|
||
if (currentTokenCount > tokenLimit * 0.1) {
|
||
shouldSplit = true;
|
||
}
|
||
}
|
||
else if (!inCodeBlock && headingRegex.test(line)) {
|
||
const match = line.match(headingRegex);
|
||
if (match && match[1].length <= 2 && currentTokenCount > tokenLimit * 0.5) {
|
||
shouldSplit = true;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (shouldSplit) {
|
||
chunks.push(currentChunkLines.join('\n'));
|
||
currentChunkLines = [];
|
||
currentTokenCount = 0;
|
||
}
|
||
|
||
currentChunkLines.push(line);
|
||
currentTokenCount += lineTokens;
|
||
}
|
||
|
||
if (currentChunkLines.length > 0) {
|
||
chunks.push(currentChunkLines.join('\n'));
|
||
}
|
||
|
||
if (typeof addProgressLog === "function") {
|
||
addProgressLog(`${logContext} 初始分割为 ${chunks.length} 个片段.`);
|
||
}
|
||
|
||
const finalChunks = [];
|
||
for(let j = 0; j < chunks.length; j++) {
|
||
const chunk = chunks[j];
|
||
const chunkTokens = estimateTokenCount(chunk);
|
||
if (chunkTokens > tokenLimit * 1.1) {
|
||
if (typeof addProgressLog === "function") {
|
||
addProgressLog(`${logContext} 警告: 第 ${j+1} 段 (${chunkTokens} tokens) 仍然超过限制 ${tokenLimit}. 尝试段落分割.`);
|
||
}
|
||
const subChunks = splitByParagraphs(chunk, tokenLimit, logContext, j+1);
|
||
finalChunks.push(...subChunks);
|
||
} else {
|
||
finalChunks.push(chunk);
|
||
}
|
||
}
|
||
|
||
if (finalChunks.length !== chunks.length && typeof addProgressLog === "function") {
|
||
addProgressLog(`${logContext} 二次分割后总片段数: ${finalChunks.length}`);
|
||
}
|
||
|
||
return finalChunks;
|
||
}
|
||
|
||
/**
|
||
* 按段落分割过大的文本块。
|
||
* 当 `splitMarkdownIntoChunks` 初步分割后，某些块可能仍然过大，
|
||
* 此函数尝试将这些超大块按照 Markdown 的段落（空行分隔）进一步细分。
|
||
*
|
||
* 主要逻辑：
|
||
* 1. **段落分割**：使用 `text.split('\n\n')` 将文本块分割成段落数组。
|
||
* 2. **逐段累加与分割**：
|
||
* - 遍历每个段落。
|
||
* - 估算段落的 token 数。
|
||
* - 如果单个段落本身就超过 `tokenLimit * 1.1`，则直接将其作为一个独立的块（不再细分），并记录警告。
|
||
* - 否则，将段落加入当前子块，并累加 token 数。
|
||
* - 如果加入当前段落会导致子块超过 `tokenLimit`，并且子块中已有内容，则先将当前子块保存，然后开始新的子块。
|
||
* 3. **日志记录**：记录段落分割的过程和结果。
|
||
*
|
||
* @param {string} text - 需要按段落分割的文本块。
|
||
* @param {number} tokenLimit - 每块的最大token数。
|
||
* @param {string} logContext - 日志前缀。
|
||
* @param {number} chunkIndex - 当前块在原始分割结果中的索引 (用于日志)。
|
||
* @returns {Array<string>} 分割后的子块数组。
|
||
*/
|
||
function splitByParagraphs(text, tokenLimit, logContext, chunkIndex) {
|
||
if (typeof addProgressLog === "function") {
|
||
addProgressLog(`${logContext} 对第 ${chunkIndex} 段进行段落分割...`);
|
||
}
|
||
const paragraphs = text.split('\n\n');
|
||
const chunks = [];
|
||
let currentChunkLines = [];
|
||
let currentTokenCount = 0;
|
||
|
||
for (const paragraph of paragraphs) {
|
||
const paragraphTokens = estimateTokenCount(paragraph);
|
||
|
||
if (paragraphTokens > tokenLimit * 1.1) {
|
||
if (typeof addProgressLog === "function") {
|
||
addProgressLog(`${logContext} 警告: 第 ${chunkIndex} 段中的段落 (${paragraphTokens} tokens) 超过限制 ${tokenLimit}. 将尝试按原样处理.`);
|
||
}
|
||
if (currentChunkLines.length > 0) {
|
||
chunks.push(currentChunkLines.join('\n\n'));
|
||
}
|
||
chunks.push(paragraph); // Keep the large paragraph as a single chunk
|
||
currentChunkLines = [];
|
||
currentTokenCount = 0;
|
||
continue;
|
||
}
|
||
|
||
if (currentTokenCount + paragraphTokens > tokenLimit && currentChunkLines.length > 0) {
|
||
chunks.push(currentChunkLines.join('\n\n'));
|
||
currentChunkLines = [];
|
||
currentTokenCount = 0;
|
||
}
|
||
|
||
currentChunkLines.push(paragraph);
|
||
currentTokenCount += paragraphTokens;
|
||
}
|
||
|
||
if (currentChunkLines.length > 0) {
|
||
chunks.push(currentChunkLines.join('\n\n'));
|
||
}
|
||
if (typeof addProgressLog === "function") {
|
||
addProgressLog(`${logContext} 第 ${chunkIndex} 段分割为 ${chunks.length} 个子段.`);
|
||
}
|
||
return chunks;
|
||
}
|
||
|
||
/**
|
||
* 翻译长文档，支持分段、表格保护、并发控制和自定义模型配置。
|
||
*
|
||
* 核心流程：
|
||
* 1. **参数准备与 Token 限制**：
|
||
* - 确保 `tokenLimitInput` 被正确解析为数字。
|
||
* 2. **表格保护**：
|
||
* - 调用 `protectMarkdownTables` (如果可用) 将 Markdown 中的表格替换为占位符 (如 `__TABLE_PLACEHOLDER_0__`)，
|
||
* 并将原始表格内容存储在 `tablePlaceholders` 对象中。这可以防止翻译API破坏表格结构。
|
||
* - 如果检测到表格，更新系统提示 `updatedSystemPrompt`，告知模型如何处理这些占位符。
|
||
* 3. **文本分块**：
|
||
* - 使用 `splitMarkdownIntoChunks` 将经过表格保护处理的文本 (`processedText`) 分割成 `originalTextChunks`。
|
||
* 4. **API 配置构建**：
|
||
* - 根据 `model` 参数是 'custom' 还是预定义模型，调用 `buildCustomApiConfig` 或 `buildPredefinedApiConfig` 来准备 API 请求所需的配置对象 (`apiConfig`)。
|
||
* - 对于自定义模型，会从 `modelConfig` 参数中获取详细配置（如端点、模型ID、请求格式等）。
|
||
* 5. **创建翻译任务队列 (`allTranslationTasks`)**：
|
||
* - 将所有文本块的翻译任务添加到队列中。
|
||
* - 如果有受保护的表格，将每个表格的翻译也作为一个独立的任务添加到队列中。
|
||
* 6. **并发翻译与重试**：
|
||
* - 遍历 `allTranslationTasks`，为每个任务创建一个异步翻译 Promise。
|
||
* - 使用 `acquireSlot` 和 `releaseSlot` 控制并发翻译的数量。
|
||
* - 对每个任务执行翻译：
|
||
* - **文本块翻译**：调用 `translateMarkdown` (并根据模型类型传递必要的参数，如 `modelConfig` for custom)。
|
||
* - **表格翻译**：构造特定的系统提示和用户提示，指导模型仅翻译表格内容并保持结构，然后调用 `callTranslationApi`。翻译结果会经过 `extractTableFromTranslation` 清理。
|
||
* - 实现重试机制 (最多 `MAX_TRANSLATION_RETRIES` 次)，使用 `getRetryDelay` 计算退避延迟。
|
||
* - 如果任务在多次重试后仍然失败，则记录错误，并将原文（或原始表格内容）作为翻译结果的兜底。
|
||
* - 将所有任务的翻译结果（成功或失败的兜底）存储在 `translationResults` Map 中，键为 `text-{index}` 或 `table-{index}`。
|
||
* 7. **等待所有任务完成**：使用 `Promise.all` 等待所有翻译 Promise 执行完毕。
|
||
* 8. **结果组装与表格还原**：
|
||
* - **构建翻译后表格映射**：从 `translationResults` 中提取已翻译的表格内容，存入 `translatedTablePlaceholders`。
|
||
* - **还原分块中的表格**：
|
||
* - 对 `originalTextChunks` 中的每个块，使用 `restoreMarkdownTables` 和原始 `tablePlaceholders` 还原其包含的原始表格，得到 `restoredOcrChunks`。
|
||
* - 对 `translationResults` 中每个文本块的翻译结果，使用 `restoreMarkdownTables` 和 `translatedTablePlaceholders` 还原其包含的已翻译表格，得到 `translatedTextChunks`。
|
||
* - **合并翻译文本**：将 `translatedTextChunks` 连接起来得到 `combinedTranslation`。
|
||
* - **最终表格还原**：为保险起见，再次对 `combinedTranslation` 使用 `translatedTablePlaceholders` 进行一次整体的表格占位符替换。
|
||
* 9. **返回结果**：返回一个对象，包含最终的完整翻译文本 `translatedText`，以及还原了表格的原文分块 `originalChunks` 和译文分块 `translatedTextChunks`。
|
||
*
|
||
* @param {string} markdownText - 待翻译的Markdown文本。
|
||
* @param {string} targetLang - 目标语言代码 (如 'zh-CN', 'en')。
|
||
* @param {string} model - 使用的翻译模型名称 (如 'mistral', 'custom')。
|
||
* @param {string} apiKey - 对应翻译模型的 API 密钥。
|
||
* @param {Object | null} modelConfig - 当 `model` 为 "custom" 时，提供自定义模型的配置对象，
|
||
* 包含 `apiEndpoint` (或 `apiBaseUrl`), `modelId`, `requestFormat`, `temperature`, `max_tokens` 等。
|
||
* @param {number | string} tokenLimitInput - 每个翻译分块的最大 token 限制。
|
||
* @param {function} acquireSlot - 用于获取并发执行槽位的函数。
|
||
* @param {function} releaseSlot - 用于释放并发执行槽位的函数。
|
||
* @param {string} [logContext=""] - 日志记录的上下文前缀。
|
||
* @param {string} [defaultSystemPrompt=""] - 默认的系统提示词。
|
||
* @param {string} [defaultUserPromptTemplate=""] - 默认的用户提示词模板 (应包含 `${content}` 和 `${targetLangName}` 占位符)。
|
||
* @param {boolean} [useCustomPrompts=false] - 是否使用自定义的提示词（如果为 false，则使用内置或默认提示词）。
|
||
* @returns {Promise<Object>} 一个包含翻译结果的对象，结构为：
|
||
* `{ translatedText: string, originalChunks: Array<string>, translatedTextChunks: Array<string> }`。
|
||
* `originalChunks` 和 `translatedTextChunks` 是经过表格还原处理后的分块数组。
|
||
* @throws {Error} 如果自定义模型配置不完整或发生其他严重错误。
|
||
*/
|
||
async function translateLongDocument(
|
||
markdownText,
|
||
targetLang,
|
||
model,
|
||
apiKey,
|
||
modelConfig, // 新增参数
|
||
tokenLimitInput,
|
||
acquireSlot,
|
||
releaseSlot,
|
||
logContext = "",
|
||
defaultSystemPrompt = "",
|
||
defaultUserPromptTemplate = "",
|
||
useCustomPrompts = false
|
||
) {
|
||
console.log('translateLongDocument: apiKey', apiKey);
|
||
const tokenLimit = parseInt(tokenLimitInput, 10) || 2000; // 确保是数字，提供默认值
|
||
|
||
// 先进行表格保护处理
|
||
let processedText = markdownText;
|
||
let tablePlaceholders = {};
|
||
let hasProtectedTables = false;
|
||
|
||
if (typeof protectMarkdownTables === 'function') {
|
||
const processed = protectMarkdownTables(markdownText);
|
||
processedText = processed.processedText;
|
||
tablePlaceholders = processed.tablePlaceholders;
|
||
hasProtectedTables = Object.keys(tablePlaceholders).length > 0;
|
||
|
||
if (hasProtectedTables) {
|
||
console.log(`${logContext} 长文档中检测到 ${Object.keys(tablePlaceholders).length} 个表格，已进行特殊保护`);
|
||
if (typeof addProgressLog === "function") {
|
||
addProgressLog(`${logContext} 长文档翻译: 已保护 ${Object.keys(tablePlaceholders).length} 个表格结构，将作为整体处理`);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 增加表格处理提示到系统提示中
|
||
let updatedSystemPrompt = defaultSystemPrompt;
|
||
if (hasProtectedTables) {
|
||
updatedSystemPrompt = defaultSystemPrompt + "\n\n注意：文档中的表格已被特殊标记为占位符（如__TABLE_PLACEHOLDER_0__），请直接翻译占位符以外的内容，保持占位符不变。表格将在后续步骤中单独处理。";
|
||
}
|
||
|
||
// 继续原有的分块处理逻辑 - 使用处理后的文本
|
||
const originalTextChunks = splitMarkdownIntoChunks(processedText, tokenLimit, logContext);
|
||
console.log(`${logContext} 文档分割为 ${originalTextChunks.length} 部分进行翻译 (Limit: ${tokenLimit})`);
|
||
if (typeof addProgressLog === "function") {
|
||
addProgressLog(`${logContext} 文档被分割为 ${originalTextChunks.length} 部分进行翻译`);
|
||
}
|
||
|
||
// 准备API配置用于文本和表格翻译
|
||
let apiConfig;
|
||
if (model === "custom") {
|
||
// 兼容 apiEndpoint 和 apiBaseUrl
|
||
const endpoint = modelConfig.apiEndpoint || modelConfig.apiBaseUrl;
|
||
if (!modelConfig || !endpoint || !modelConfig.modelId) {
|
||
throw new Error('Custom model configuration is incomplete for translateLongDocument. API Endpoint (或 apiBaseUrl) and Model ID are required.');
|
||
}
|
||
apiConfig = buildCustomApiConfig(
|
||
apiKey,
|
||
endpoint, // 兼容 apiEndpoint 和 apiBaseUrl
|
||
modelConfig.modelId, // 使用传入的 modelConfig
|
||
modelConfig.requestFormat, // 使用传入的 modelConfig
|
||
modelConfig.temperature,
|
||
modelConfig.max_tokens,
|
||
{
|
||
endpointMode: modelConfig.endpointMode || 'auto'
|
||
}
|
||
);
|
||
} else {
|
||
// 预设模型
|
||
const settingsForModels = typeof loadSettings === 'function' ? loadSettings() : {};
|
||
const customModelSettings = settingsForModels && settingsForModels.customModelSettings ? settingsForModels.customModelSettings : {};
|
||
let temperature = 0.5;
|
||
if (customModelSettings.temperature !== undefined && customModelSettings.temperature !== null && customModelSettings.temperature !== '') {
|
||
const parsedTemp = parseFloat(customModelSettings.temperature);
|
||
if (!Number.isNaN(parsedTemp)) {
|
||
temperature = parsedTemp;
|
||
}
|
||
}
|
||
let maxTokens = 8000;
|
||
if (customModelSettings.max_tokens !== undefined && customModelSettings.max_tokens !== null && customModelSettings.max_tokens !== '') {
|
||
const parsedMax = parseInt(customModelSettings.max_tokens, 10);
|
||
if (!Number.isNaN(parsedMax) && parsedMax > 0) {
|
||
maxTokens = parsedMax;
|
||
}
|
||
}
|
||
|
||
let geminiEndpointDynamic = 'https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent';
|
||
try {
|
||
if (typeof loadModelConfig === 'function') {
|
||
const gcfg = loadModelConfig('gemini');
|
||
const preferred = gcfg && (gcfg.preferredModelId || gcfg.modelId);
|
||
if (preferred && typeof preferred === 'string' && preferred.trim()) {
|
||
geminiEndpointDynamic = `https://generativelanguage.googleapis.com/v1beta/models/${preferred.trim()}:generateContent`;
|
||
}
|
||
}
|
||
} catch (e) {
|
||
console.warn('加载 Gemini 配置失败，将在长文档翻译中使用默认模型。', e);
|
||
}
|
||
|
||
let deeplxEndpointTemplate = 'https://api.deeplx.org/<api-key>/translate';
|
||
try {
|
||
if (typeof loadModelConfig === 'function') {
|
||
const dlcfg = loadModelConfig('deeplx');
|
||
if (dlcfg) {
|
||
if (dlcfg.endpointTemplate && typeof dlcfg.endpointTemplate === 'string') {
|
||
deeplxEndpointTemplate = dlcfg.endpointTemplate.trim() || deeplxEndpointTemplate;
|
||
} else if (dlcfg.apiBaseUrlTemplate && typeof dlcfg.apiBaseUrlTemplate === 'string') {
|
||
deeplxEndpointTemplate = dlcfg.apiBaseUrlTemplate.trim() || deeplxEndpointTemplate;
|
||
} else if (dlcfg.apiBaseUrl && typeof dlcfg.apiBaseUrl === 'string') {
|
||
const base = dlcfg.apiBaseUrl.trim();
|
||
if (base) {
|
||
deeplxEndpointTemplate = base.endsWith('/') ? `${base}<api-key>/translate` : `${base}/<api-key>/translate`;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
} catch (e) {
|
||
console.warn('加载 DeepLX 配置失败，将在长文档翻译中使用默认模板。', e);
|
||
}
|
||
|
||
const predefinedConfigs = {
|
||
"mistral": {
|
||
endpoint: "https://api.mistral.ai/v1/chat/completions",
|
||
modelName: "mistral-large-latest",
|
||
headers: { "Content-Type": "application/json" },
|
||
bodyBuilder: (sys, user) => ({
|
||
model: "mistral-large-latest",
|
||
messages: [
|
||
{ role: "system", content: sys },
|
||
{ role: "user", content: user }
|
||
],
|
||
temperature: temperature,
|
||
max_tokens: maxTokens
|
||
}),
|
||
responseExtractor: (data) => data?.choices?.[0]?.message?.content
|
||
},
|
||
"deepseek": {
|
||
endpoint: "https://api.deepseek.com/v1/chat/completions",
|
||
modelName: "DeepSeek",
|
||
headers: { "Content-Type": "application/json" },
|
||
bodyBuilder: (sys, user) => {
|
||
let modelId = 'deepseek-chat';
|
||
try { const cfg = loadModelConfig && loadModelConfig('deepseek'); if (cfg && (cfg.preferredModelId || cfg.modelId)) modelId = cfg.preferredModelId || cfg.modelId; } catch (_) {}
|
||
return {
|
||
model: modelId,
|
||
messages: [
|
||
{ role: "system", content: sys },
|
||
{ role: "user", content: user }
|
||
],
|
||
temperature: temperature,
|
||
max_tokens: maxTokens
|
||
};
|
||
},
|
||
responseExtractor: (data) => data?.choices?.[0]?.message?.content
|
||
},
|
||
"gemini": {
|
||
endpoint: geminiEndpointDynamic,
|
||
modelName: "Google Gemini",
|
||
headers: { "Content-Type": "application/json" },
|
||
bodyBuilder: (sys, user) => ({
|
||
contents: [
|
||
{
|
||
role: "user",
|
||
parts: [{ text: `${sys}\n\n${user}` }]
|
||
}
|
||
],
|
||
generationConfig: {
|
||
temperature: temperature,
|
||
maxOutputTokens: maxTokens
|
||
}
|
||
}),
|
||
responseExtractor: (data) => {
|
||
if (data?.candidates && data.candidates.length > 0 && data.candidates[0].content) {
|
||
const parts = data.candidates[0].content.parts;
|
||
return parts && parts.length > 0 ? parts[0].text : '';
|
||
}
|
||
return '';
|
||
}
|
||
},
|
||
"gemini-preview": {
|
||
endpoint: "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-preview-05-20:generateContent",
|
||
modelName: "Google gemini-2.5-flash-preview-05-20",
|
||
headers: { "Content-Type": "application/json" },
|
||
bodyBuilder: (sys, user) => ({
|
||
contents: [
|
||
{
|
||
role: "user",
|
||
parts: [{ text: `${sys}\n\n${user}` }]
|
||
}
|
||
],
|
||
generationConfig: {
|
||
temperature: temperature,
|
||
maxOutputTokens: maxTokens,
|
||
responseModalities: ["TEXT"],
|
||
responseMimeType: "text/plain"
|
||
}
|
||
}),
|
||
responseExtractor: (data) => {
|
||
if (data?.candidates && data.candidates.length > 0 && data.candidates[0].content) {
|
||
const parts = data.candidates[0].content.parts;
|
||
return parts && parts.length > 0 ? parts[0].text : '';
|
||
}
|
||
return '';
|
||
}
|
||
},
|
||
"tongyi": {
|
||
endpoint: "https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions",
|
||
modelName: "通义百炼",
|
||
headers: { "Content-Type": "application/json" },
|
||
bodyBuilder: (sys, user) => {
|
||
let modelId = 'qwen-turbo-latest';
|
||
try { const cfg = loadModelConfig && loadModelConfig('tongyi'); if (cfg && (cfg.preferredModelId || cfg.modelId)) modelId = cfg.preferredModelId || cfg.modelId; } catch (_) {}
|
||
const isQwenMT = typeof modelId === 'string' && modelId.toLowerCase().includes('qwen-mt');
|
||
const mergedContent = isQwenMT ? `${sys}\n\n${user}`.trim() : null;
|
||
return {
|
||
model: modelId,
|
||
messages: isQwenMT
|
||
? [
|
||
{ role: "user", content: mergedContent }
|
||
]
|
||
: [
|
||
{ role: "system", content: sys },
|
||
{ role: "user", content: user }
|
||
],
|
||
temperature: temperature,
|
||
max_tokens: maxTokens,
|
||
enable_thinking: false
|
||
};
|
||
},
|
||
responseExtractor: (data) => data?.choices?.[0]?.message?.content
|
||
},
|
||
"volcano": {
|
||
endpoint: "https://ark.cn-beijing.volces.com/api/v3/chat/completions",
|
||
modelName: "火山引擎",
|
||
headers: { "Content-Type": "application/json" },
|
||
bodyBuilder: (sys, user) => {
|
||
let modelId = 'doubao-1-5-pro-32k-250115';
|
||
try { const cfg = loadModelConfig && loadModelConfig('volcano'); if (cfg && (cfg.preferredModelId || cfg.modelId)) modelId = cfg.preferredModelId || cfg.modelId; } catch (_) {}
|
||
return {
|
||
model: modelId,
|
||
messages: [
|
||
{ role: "system", content: sys },
|
||
{ role: "user", content: user }
|
||
],
|
||
temperature: temperature,
|
||
max_tokens: Math.min(maxTokens, 16384)
|
||
};
|
||
},
|
||
responseExtractor: (data) => data?.choices?.[0]?.message?.content
|
||
},
|
||
"deeplx": {
|
||
endpoint: deeplxEndpointTemplate,
|
||
modelName: "DeepLX",
|
||
headers: { "Content-Type": "application/json" },
|
||
bodyBuilder: (sys, user, ctx = {}) => {
|
||
const payload = {
|
||
text: ctx && ctx.processedText ? ctx.processedText : user
|
||
};
|
||
const targetLangCode = (typeof mapToDeeplxLangCode === 'function')
|
||
? mapToDeeplxLangCode(ctx && ctx.targetLang ? ctx.targetLang : undefined)
|
||
: undefined;
|
||
if (targetLangCode) {
|
||
payload.target_lang = targetLangCode;
|
||
}
|
||
if (ctx && ctx.sourceLang) {
|
||
const src = (typeof mapToDeeplxLangCode === 'function') ? mapToDeeplxLangCode(ctx.sourceLang) : undefined;
|
||
if (src) payload.source_lang = src;
|
||
}
|
||
return payload;
|
||
},
|
||
responseExtractor: (data) => {
|
||
if (!data) return '';
|
||
if (typeof data === 'string') return data;
|
||
if (typeof data.text === 'string') return data.text;
|
||
if (data.data) {
|
||
if (typeof data.data === 'string') return data.data;
|
||
if (typeof data.data.text === 'string') return data.data.text;
|
||
}
|
||
if (Array.isArray(data.translations) && data.translations.length > 0) {
|
||
const first = data.translations[0];
|
||
if (typeof first === 'string') return first;
|
||
if (first && typeof first.text === 'string') return first.text;
|
||
}
|
||
if (Array.isArray(data.alternatives) && data.alternatives.length > 0) {
|
||
const alt = data.alternatives[0];
|
||
if (typeof alt === 'string') return alt;
|
||
if (alt && typeof alt.text === 'string') return alt.text;
|
||
}
|
||
if (typeof data.result === 'string') return data.result;
|
||
if (data.result && typeof data.result.text === 'string') return data.result.text;
|
||
if (typeof data.translation === 'string') return data.translation;
|
||
return null;
|
||
}
|
||
}
|
||
};
|
||
|
||
if (!predefinedConfigs[model]) {
|
||
throw new Error(`暂不支持模型 ${model} 的长文档处理。`);
|
||
}
|
||
apiConfig = buildPredefinedApiConfig(predefinedConfigs[model], apiKey);
|
||
}
|
||
|
||
// 创建所有翻译任务的统一队列（包括文本块和表格）
|
||
const allTranslationTasks = [];
|
||
|
||
// 添加所有文本块翻译任务
|
||
originalTextChunks.forEach((part, i) => {
|
||
allTranslationTasks.push({
|
||
type: 'text',
|
||
index: i,
|
||
content: part,
|
||
context: `${logContext} (Part ${i+1}/${originalTextChunks.length})`
|
||
});
|
||
});
|
||
|
||
// 添加所有表格翻译任务（如果有）
|
||
if (hasProtectedTables) {
|
||
let tableIndex = 0;
|
||
for (const [placeholder, tableContent] of Object.entries(tablePlaceholders)) {
|
||
allTranslationTasks.push({
|
||
type: 'table',
|
||
index: tableIndex,
|
||
placeholder: placeholder,
|
||
content: tableContent,
|
||
context: `${logContext} (Table ${tableIndex+1}/${Object.keys(tablePlaceholders).length})`
|
||
});
|
||
tableIndex++;
|
||
}
|
||
}
|
||
|
||
if (typeof addProgressLog === "function") {
|
||
addProgressLog(`${logContext} 总计待翻译任务: ${allTranslationTasks.length} (文本块: ${originalTextChunks.length}, 表格: ${hasProtectedTables ? Object.keys(tablePlaceholders).length : 0})`);
|
||
}
|
||
|
||
let hasErrors = false;
|
||
const MAX_TRANSLATION_RETRIES = 3;
|
||
const translationResults = new Map(); // 使用Map存储翻译结果
|
||
|
||
// 为所有任务创建翻译Promise
|
||
const translationPromises = allTranslationTasks.map(async (task) => {
|
||
const taskLogContext = task.context;
|
||
let lastError = null;
|
||
|
||
for (let attempt = 0; attempt <= MAX_TRANSLATION_RETRIES; attempt++) {
|
||
const attemptNum = attempt + 1;
|
||
if (typeof addProgressLog === "function") {
|
||
addProgressLog(`${taskLogContext} 排队等待翻译槽 (尝试 ${attemptNum})...`);
|
||
}
|
||
await acquireSlot();
|
||
if (typeof addProgressLog === "function") {
|
||
addProgressLog(`${taskLogContext} 翻译槽已获取。开始翻译 ${task.type === 'table' ? '表格' : '文本'} (尝试 ${attemptNum})...`);
|
||
}
|
||
|
||
try {
|
||
let result;
|
||
|
||
if (task.type === 'text') {
|
||
// Step 1: 为任务预绑定提示词并入队，便于失败时做“真正队列替换”
|
||
let boundPrompt = null;
|
||
let requestId = `req_${Date.now()}_${Math.random().toString(36).slice(2,8)}_t${task.index}`;
|
||
try {
|
||
if (typeof window !== 'undefined' && window.promptPoolUI && typeof window.promptPoolUI.getPromptForTranslation === 'function') {
|
||
const p = window.promptPoolUI.getPromptForTranslation();
|
||
// 仅当池模式返回 id/system/user 时认为可用
|
||
if (p && p.id && p.systemPrompt && p.userPromptTemplate) {
|
||
boundPrompt = p;
|
||
if (typeof window.translationPromptPool !== 'undefined' && typeof window.translationPromptPool.enqueueRequest === 'function') {
|
||
window.translationPromptPool.enqueueRequest(p.id, { requestId, model: (apiConfig && apiConfig.modelName) || model });
|
||
}
|
||
}
|
||
}
|
||
} catch (e) {
|
||
console.warn('[PromptPool] 预绑定提示词失败（跳过绑定）:', e);
|
||
}
|
||
// 翻译文本块
|
||
//console.log('document.js 调用 translateMarkdown 参数:', {
|
||
// useCustomPrompts,
|
||
// defaultUserPromptTemplate,
|
||
// defaultSystemPrompt,
|
||
// modelConfig,
|
||
// content: task.content,
|
||
// targetLang,
|
||
// model,
|
||
// apiKey,
|
||
// taskLogContext
|
||
//});
|
||
if (model === 'custom') {
|
||
result = await translateMarkdown(
|
||
task.content,
|
||
targetLang,
|
||
model,
|
||
apiKey,
|
||
modelConfig,
|
||
taskLogContext,
|
||
updatedSystemPrompt,
|
||
defaultUserPromptTemplate,
|
||
useCustomPrompts,
|
||
false,
|
||
{ boundPrompt, requestId }
|
||
);
|
||
} else {
|
||
result = await translateMarkdown(
|
||
task.content,
|
||
targetLang,
|
||
model,
|
||
apiKey,
|
||
taskLogContext,
|
||
updatedSystemPrompt,
|
||
defaultUserPromptTemplate,
|
||
useCustomPrompts,
|
||
false,
|
||
{ boundPrompt, requestId }
|
||
);
|
||
}
|
||
//console.log('document.js translateMarkdown 返回:', result);
|
||
translationResults.set('text-' + task.index, result);
|
||
} else if (task.type === 'table') {
|
||
// 翻译表格
|
||
let tableSystemPrompt = `你是一个精确翻译表格的助手。请将表格翻译成${targetLang}，严格保持以下格式要求：
|
||
1. 保持所有表格分隔符（|）和结构完全不变
|
||
2. 保持表格对齐标记（:--:、:--、--:）不变
|
||
3. 保持表格的行数和列数完全一致
|
||
4. 保持数学公式、符号和百分比等专业内容不变
|
||
5. 翻译表格标题（如有）和表格内的文本内容
|
||
6. 表格内容与表格外内容要明确区分`;
|
||
|
||
// 注入术语库（如启用且有命中）
|
||
try {
|
||
const settingsForGlossary = (typeof loadSettings === 'function') ? loadSettings() : {};
|
||
const glossaryEnabled = !!settingsForGlossary.enableGlossary;
|
||
if (glossaryEnabled && typeof getGlossaryMatchesForText === 'function') {
|
||
const matches = getGlossaryMatchesForText(task.content);
|
||
if (matches && matches.length > 0 && typeof buildGlossaryInstruction === 'function') {
|
||
const instr = buildGlossaryInstruction(matches, targetLang);
|
||
if (instr) {
|
||
tableSystemPrompt = tableSystemPrompt + "\n\n" + instr;
|
||
if (typeof addProgressLog === 'function') {
|
||
const names = matches.slice(0, 6).map(m => m.term).join(', ');
|
||
addProgressLog(`${taskLogContext} [表格] 命中备择库 ${matches.length} 条：${names}${matches.length>6?'...':''}`);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
} catch (e) {
|
||
console.warn('Glossary injection for table skipped due to error:', e);
|
||
}
|
||
|
||
// 用户提示词
|
||
const tableUserPrompt = `请将以下Markdown表格翻译成${targetLang}，请确保完全保持表格结构和格式：
|
||
|
||
${task.content}
|
||
|
||
注意：请保持表格格式完全不变，包括所有的 | 符号、对齐标记、数学公式和符号。`;
|
||
|
||
// 构建请求体
|
||
const requestBody = apiConfig.bodyBuilder
|
||
? apiConfig.bodyBuilder(tableSystemPrompt, tableUserPrompt, {
|
||
processedText: task.content,
|
||
rawText: task.content,
|
||
targetLang,
|
||
tablePlaceholder: task.placeholder,
|
||
requestType: 'table'
|
||
})
|
||
: {
|
||
model: apiConfig.modelName,
|
||
messages: [
|
||
{ role: "system", content: tableSystemPrompt },
|
||
{ role: "user", content: tableUserPrompt }
|
||
]
|
||
};
|
||
|
||
// 调用API翻译表格
|
||
const translatedTable = await callTranslationApi(apiConfig, requestBody);
|
||
|
||
// 提取和清理翻译结果中的表格部分
|
||
const cleanedTable = typeof extractTableFromTranslation === 'function' ?
|
||
(extractTableFromTranslation(translatedTable) || task.content) :
|
||
task.content;
|
||
|
||
translationResults.set('table-' + task.index, {
|
||
placeholder: task.placeholder,
|
||
translatedContent: cleanedTable
|
||
});
|
||
}
|
||
|
||
if (typeof releaseSlot === "function") {
|
||
releaseSlot();
|
||
}
|
||
if (typeof addProgressLog === "function") {
|
||
addProgressLog(`${taskLogContext} 翻译槽已释放 (成功)。`);
|
||
}
|
||
return; // 成功，退出重试循环
|
||
|
||
} catch (error) {
|
||
// 释放翻译槽
|
||
if (typeof releaseSlot === "function") {
|
||
releaseSlot();
|
||
}
|
||
if (typeof addProgressLog === "function") {
|
||
addProgressLog(`${taskLogContext} 翻译槽已释放 (失败)。`);
|
||
}
|
||
lastError = error;
|
||
console.error(`${taskLogContext} 翻译失败 (尝试 ${attemptNum}/${MAX_TRANSLATION_RETRIES + 1}):`, error);
|
||
if (typeof addProgressLog === "function") {
|
||
addProgressLog(`${taskLogContext} 警告: 翻译失败 (尝试 ${attemptNum}/${MAX_TRANSLATION_RETRIES + 1}) - ${error.message}.`);
|
||
}
|
||
|
||
if (attempt < MAX_TRANSLATION_RETRIES) {
|
||
const delay = typeof getRetryDelay === 'function' ?
|
||
getRetryDelay(attempt) :
|
||
Math.min(1000 * Math.pow(2, attempt), 30000);
|
||
|
||
if (typeof addProgressLog === "function") {
|
||
addProgressLog(`${taskLogContext} ${delay.toFixed(0)}ms 后重试...`);
|
||
}
|
||
await new Promise(resolve => setTimeout(resolve, delay));
|
||
} else {
|
||
if (typeof addProgressLog === "function") {
|
||
addProgressLog(`${taskLogContext} 已达最大重试次数 (${MAX_TRANSLATION_RETRIES + 1}次尝试)，使用原文。`);
|
||
}
|
||
hasErrors = true;
|
||
|
||
// 保存原始内容作为结果
|
||
if (task.type === 'text') {
|
||
translationResults.set('text-' + task.index,
|
||
`\n\n> **[翻译错误 (重试 ${MAX_TRANSLATION_RETRIES + 1} 次失败) - 保留原文 Part ${task.index+1}]**\n\n${task.content}\n\n`);
|
||
} else if (task.type === 'table') {
|
||
translationResults.set('table-' + task.index, {
|
||
placeholder: task.placeholder,
|
||
translatedContent: task.content
|
||
});
|
||
}
|
||
return; // 结束重试
|
||
}
|
||
}
|
||
}
|
||
|
||
console.error(`${taskLogContext} Unexpected state reached after retry loop.`);
|
||
if (typeof addProgressLog === "function") {
|
||
addProgressLog(`${taskLogContext} 警告: 翻译重试逻辑结束后状态意外，保留原文。`);
|
||
}
|
||
hasErrors = true;
|
||
|
||
// 安全兜底，保存原始内容
|
||
if (task.type === 'text') {
|
||
translationResults.set('text-' + task.index,
|
||
`\n\n> **[翻译意外失败 - 保留原文 Part ${task.index+1}]**\n\n${task.content}\n\n`);
|
||
} else if (task.type === 'table') {
|
||
translationResults.set('table-' + task.index, {
|
||
placeholder: task.placeholder,
|
||
translatedContent: task.content
|
||
});
|
||
}
|
||
});
|
||
|
||
// 等待所有并发翻译任务完成
|
||
try {
|
||
await Promise.all(translationPromises);
|
||
} catch (error) {
|
||
console.error(`${logContext} An unexpected error occurred during Promise.all for translations:`, error);
|
||
if (typeof addProgressLog === "function") {
|
||
addProgressLog(`${logContext} 错误: 并发翻译过程中出现意外错误。`);
|
||
}
|
||
hasErrors = true;
|
||
}
|
||
|
||
if (hasErrors) {
|
||
if (typeof addProgressLog === "function") {
|
||
addProgressLog(`${logContext} 部分或全部翻译任务处理失败 (已完成重试)。`);
|
||
}
|
||
} else {
|
||
if (typeof addProgressLog === "function") {
|
||
addProgressLog(`${logContext} 所有翻译任务处理完成。`);
|
||
}
|
||
}
|
||
|
||
// 构建翻译后表格占位符映射
|
||
let translatedTablePlaceholders = {};
|
||
if (hasProtectedTables) {
|
||
for (let i = 0; i < Object.keys(tablePlaceholders).length; i++) {
|
||
const tableResult = translationResults.get('table-' + i);
|
||
if (tableResult && tableResult.placeholder) {
|
||
translatedTablePlaceholders[tableResult.placeholder] = tableResult.translatedContent;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 收集所有文本块的翻译结果（原文和译文都做表格还原）
|
||
const restoredOcrChunks = [];
|
||
const translatedTextChunks = [];
|
||
for (let i = 0; i < originalTextChunks.length; i++) {
|
||
let ocrChunk = originalTextChunks[i];
|
||
let translatedChunk = translationResults.get('text-' + i);
|
||
// 原文分块还原原文表格
|
||
if (hasProtectedTables && typeof restoreMarkdownTables === 'function') {
|
||
ocrChunk = await restoreMarkdownTables(ocrChunk, tablePlaceholders);
|
||
}
|
||
// 译文分块还原翻译后表格
|
||
if (hasProtectedTables && typeof restoreMarkdownTables === 'function') {
|
||
translatedChunk = await restoreMarkdownTables(translatedChunk, translatedTablePlaceholders);
|
||
}
|
||
restoredOcrChunks.push(ocrChunk);
|
||
translatedTextChunks.push(translatedChunk || originalTextChunks[i]);
|
||
}
|
||
|
||
// 合并已翻译的块
|
||
let combinedTranslation = translatedTextChunks.join('\n\n');
|
||
|
||
// 如果有表格，替换所有表格占位符（保险起见，整体再替换一遍）
|
||
if (hasProtectedTables) {
|
||
if (typeof addProgressLog === "function") {
|
||
addProgressLog(`${logContext} 正在替换表格占位符...`);
|
||
}
|
||
|
||
for (let i = 0; i < Object.keys(translatedTablePlaceholders).length; i++) {
|
||
const placeholder = Object.keys(translatedTablePlaceholders)[i];
|
||
const translatedContent = translatedTablePlaceholders[placeholder];
|
||
combinedTranslation = combinedTranslation.replace(
|
||
placeholder,
|
||
translatedContent
|
||
);
|
||
}
|
||
|
||
if (typeof addProgressLog === "function") {
|
||
addProgressLog(`${logContext} 表格占位符替换完成。`);
|
||
}
|
||
}
|
||
|
||
return {
|
||
translatedText: combinedTranslation,
|
||
originalChunks: restoredOcrChunks, // 现在是还原了表格的原文分块
|
||
translatedTextChunks: translatedTextChunks // 现在是还原了表格的译文分块
|
||
};
|
||
}
|
||
|
||
// 将函数添加到processModule对象
|
||
if (typeof processModule !== 'undefined') {
|
||
processModule.splitMarkdownIntoChunks = splitMarkdownIntoChunks;
|
||
processModule.splitByParagraphs = splitByParagraphs;
|
||
processModule.translateLongDocument = translateLongDocument;
|
||
}
|