990 lines
36 KiB
JavaScript
990 lines
36 KiB
JavaScript
/**
|
||
* API服务
|
||
* 通过后端API代理调用第三方服务，保护API密钥安全
|
||
*/
|
||
|
||
import { logger } from '../utils/logger.js';
|
||
|
||
// 用于存储进行中的请求的AbortController
|
||
const runningRequests = new Map();
|
||
|
||
// ---基础路由推断逻辑---
|
||
// 自动获取当前插件的挂载点，消除硬编码路径
|
||
// 通过解析当前脚本的 URL，提取出 extensions/ 后的目录名
|
||
let apiBaseUrl = null;
|
||
|
||
function getDynamicApiBase() {
|
||
if (apiBaseUrl) return apiBaseUrl;
|
||
|
||
try {
|
||
const scriptUrl = import.meta.url;
|
||
const url = new URL(scriptUrl);
|
||
const pathParts = url.pathname.split('/');
|
||
|
||
// 策略1：寻找 /js/ 目录段，并取其前一个段作为插件名 (最通用)
|
||
const jsIdx = pathParts.indexOf('js');
|
||
if (jsIdx > 0) {
|
||
const nodeDir = pathParts[jsIdx - 1];
|
||
apiBaseUrl = `/${nodeDir}/api`;
|
||
}
|
||
// 策略2：回退到 extensions 关键词寻找 (ComfyUI 标准结构)
|
||
else {
|
||
const extIdx = pathParts.indexOf('extensions');
|
||
if (extIdx !== -1 && pathParts.length > extIdx + 1) {
|
||
const nodeDir = pathParts[extIdx + 1];
|
||
apiBaseUrl = `/${nodeDir}/api`;
|
||
} else {
|
||
// 策略3：硬编码兜底
|
||
apiBaseUrl = '/prompt-assistant/api';
|
||
}
|
||
}
|
||
} catch (e) {
|
||
apiBaseUrl = '/prompt-assistant/api';
|
||
}
|
||
return apiBaseUrl;
|
||
}
|
||
|
||
class APIService {
|
||
/**
|
||
* 获取动态 API 基础路径
|
||
* 暴露模块级的 getDynamicApiBase 函数供外部调用
|
||
*/
|
||
static getDynamicApiBase() {
|
||
return getDynamicApiBase();
|
||
}
|
||
|
||
/**
|
||
* 构建完整的API URL
|
||
*/
|
||
static getApiUrl(path) {
|
||
// 获取动态基础路由 (例如 /comfyui_prompt_assistant/api)
|
||
const baseApi = getDynamicApiBase();
|
||
|
||
// 确保 path 不含重复的前缀，且格式正确
|
||
let subPath = path.startsWith('/') ? path : `/${path}`;
|
||
|
||
// 如果 path 已经包含了 baseApi，则不再重复添加
|
||
const fullPath = subPath.startsWith(baseApi) ? subPath : `${baseApi}${subPath}`;
|
||
|
||
const url = `${window.location.origin}${fullPath}`;
|
||
// logger.debug(`构建API URL: ${url}`);
|
||
return url;
|
||
}
|
||
|
||
/**
|
||
* 解析形如 [{"id":0,"text":"..."}, ...] 的JSON数组
|
||
* 返回 Map<id, text>
|
||
*/
|
||
static _extractIndexedTranslations(text) {
|
||
const arr = APIService._extractJsonArray(text);
|
||
if (!Array.isArray(arr)) return null;
|
||
const map = new Map();
|
||
for (const item of arr) {
|
||
if (!item || typeof item !== 'object') return null;
|
||
if (!('id' in item) || !('text' in item)) return null;
|
||
map.set(Number(item.id), String(item.text ?? ''));
|
||
}
|
||
return map;
|
||
}
|
||
|
||
/**
|
||
* 结构化批量翻译（纯前端封装，单次LLM请求）
|
||
* 要求模型严格返回 JSON 数组，与输入 texts 一一对应
|
||
*/
|
||
static async llmBatchTranslate(texts, from = 'auto', to = 'zh', request_id = null) {
|
||
try {
|
||
if (!Array.isArray(texts) || texts.length === 0) {
|
||
throw new Error('待翻译文本数组不能为空');
|
||
}
|
||
|
||
// 构造结构化指令，使用索引，要求输出严格的 JSON 对象数组
|
||
const indexed = texts.map((t, i) => ({ id: i, text: t }));
|
||
// 强化提示词：明确禁止 Markdown 表格格式，禁止添加 '|' 前缀
|
||
const sysHint = `你是一个专业的翻译API。请将输入的 JSON 数组中的 text 字段内容从 ${from} 翻译为 ${to}。
|
||
规则：
|
||
1. 保持 JSON 结构不变，返回包含 id 和 text 的数组。
|
||
2. 严禁使用 Markdown 表格格式，严禁在译文前添加 '|' 符号。
|
||
3. 对于参数名、变量名（如 snake_case 格式），请尽可能将其翻译为中文含义（例如：pose_images -> 姿势图像），除非是专有名词（如 CLIP, VAE）。
|
||
4. 保持数组长度与输入一致。
|
||
5. 直接输出 JSON，不要包含 Markdown 代码块标记（如 \`\`\`json）。`;
|
||
|
||
const payload = { segments: indexed };
|
||
const prompt = [
|
||
sysHint,
|
||
'Input: ' + JSON.stringify(payload)
|
||
].join('\n');
|
||
|
||
// 复用单文本接口
|
||
const res = await this.llmTranslate(prompt, from, to, request_id);
|
||
if (!res || !res.success) {
|
||
return { success: false, error: res?.error || '批量翻译失败' };
|
||
}
|
||
|
||
const content = (res.data && (res.data.translated || res.data.expanded || res.data.content)) || res.translated || res.content || '';
|
||
// 解析为索引映射
|
||
let mapped = APIService._extractIndexedTranslations(content);
|
||
if (!mapped) {
|
||
// 回退：尝试解析为纯字符串数组并顺序对齐
|
||
const arr = APIService._extractJsonArray(content);
|
||
if (Array.isArray(arr) && arr.length === texts.length) {
|
||
mapped = new Map(arr.map((v, i) => [i, v]));
|
||
}
|
||
}
|
||
|
||
if (!mapped) {
|
||
return { success: false, error: '解析批量译文失败：未检测到有效JSON' };
|
||
}
|
||
|
||
// 如果缺项，针对缺失索引做单次补救调用，避免整次失败
|
||
const translations = new Array(texts.length).fill("");
|
||
const missingIdx = [];
|
||
for (let i = 0; i < texts.length; i++) {
|
||
if (mapped.has(i)) {
|
||
translations[i] = mapped.get(i);
|
||
} else {
|
||
missingIdx.push(i);
|
||
}
|
||
}
|
||
|
||
if (missingIdx.length > 0) {
|
||
for (const i of missingIdx) {
|
||
const single = await this.llmTranslate(texts[i], from, to, request_id);
|
||
if (single && single.success) {
|
||
translations[i] = (single.data && single.data.translated) || '';
|
||
} else {
|
||
translations[i] = '';
|
||
}
|
||
}
|
||
}
|
||
|
||
return { success: true, data: { translations } };
|
||
} catch (error) {
|
||
return { success: false, error: error.message };
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 并行分块批量翻译（优化版本）
|
||
* 将文本数组分块后并行发起多个翻译请求，显著提升翻译速度
|
||
*
|
||
* @param {string[]} texts - 待翻译的文本数组
|
||
* @param {string} from - 源语言
|
||
* @param {string} to - 目标语言
|
||
* @param {Object} options - 配置选项
|
||
* @param {number} options.chunkSize - 每块包含的文本数量（默认5）
|
||
* @param {number} options.concurrency - 最大并发数（默认3）
|
||
* @param {Function} options.onProgress - 进度回调 (completedChunks, totalChunks)
|
||
* @returns {Promise<{success: boolean, data?: {translations: string[]}, error?: string}>}
|
||
*/
|
||
static async llmParallelBatchTranslate(texts, from = 'auto', to = 'zh', options = {}) {
|
||
const { chunkSize = 5, concurrency = 3, onProgress = null } = options;
|
||
|
||
try {
|
||
if (!Array.isArray(texts) || texts.length === 0) {
|
||
throw new Error('待翻译文本数组不能为空');
|
||
}
|
||
|
||
// 1. 分块
|
||
const chunks = [];
|
||
for (let i = 0; i < texts.length; i += chunkSize) {
|
||
chunks.push({
|
||
startIndex: i,
|
||
texts: texts.slice(i, i + chunkSize)
|
||
});
|
||
}
|
||
|
||
logger.log(`[APIService] 并行分块翻译 | 总文本数:${texts.length} | 分块数:${chunks.length} | 每块:${chunkSize} | 并发:${concurrency}`);
|
||
|
||
// 2. 创建结果数组
|
||
const allTranslations = new Array(texts.length).fill('');
|
||
let completedChunks = 0;
|
||
let hasError = false;
|
||
let lastError = null;
|
||
|
||
// 3. 并发控制函数
|
||
const translateChunk = async (chunk) => {
|
||
try {
|
||
const result = await this.llmBatchTranslate(chunk.texts, from, to);
|
||
|
||
if (result.success && result.data && result.data.translations) {
|
||
// 将翻译结果填充到对应位置
|
||
result.data.translations.forEach((translation, idx) => {
|
||
allTranslations[chunk.startIndex + idx] = translation || '';
|
||
});
|
||
} else {
|
||
// 单块失败，记录但不中断
|
||
hasError = true;
|
||
lastError = result.error || '翻译失败';
|
||
logger.warn(`[APIService] 分块翻译失败 | 起始索引:${chunk.startIndex} | 错误:${lastError}`);
|
||
}
|
||
} catch (err) {
|
||
hasError = true;
|
||
lastError = err.message;
|
||
logger.error(`[APIService] 分块翻译异常 | 起始索引:${chunk.startIndex} | 错误:${err.message}`);
|
||
} finally {
|
||
completedChunks++;
|
||
if (onProgress) {
|
||
onProgress(completedChunks, chunks.length);
|
||
}
|
||
}
|
||
};
|
||
|
||
// 4. 分批并发执行（控制最大并发数）
|
||
for (let i = 0; i < chunks.length; i += concurrency) {
|
||
const batch = chunks.slice(i, i + concurrency);
|
||
await Promise.all(batch.map(chunk => translateChunk(chunk)));
|
||
}
|
||
|
||
// 5. 检查结果
|
||
const successCount = allTranslations.filter(t => t && t.trim()).length;
|
||
logger.log(`[APIService] 并行翻译完成 | 成功:${successCount}/${texts.length}`);
|
||
|
||
// 即使部分失败也返回成功（有翻译结果）
|
||
if (successCount === 0 && texts.length > 0) {
|
||
return { success: false, error: lastError || '所有文本翻译失败' };
|
||
}
|
||
|
||
return { success: true, data: { translations: allTranslations } };
|
||
|
||
} catch (error) {
|
||
logger.error(`[APIService] 并行批量翻译失败: ${error.message}`);
|
||
return { success: false, error: error.message };
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 从字符串中提取并解析首个JSON数组
|
||
*/
|
||
static _extractJsonArray(text) {
|
||
if (!text) return null;
|
||
try {
|
||
// 快速路径：整段就是JSON数组
|
||
if (text.trim().startsWith('[')) {
|
||
return JSON.parse(text.trim());
|
||
}
|
||
} catch (_) { /* ignore */ }
|
||
|
||
// 兼容模型添加的前后缀：寻找第一个 '[' 与匹配的 ']'
|
||
const first = text.indexOf('[');
|
||
const last = text.lastIndexOf(']');
|
||
if (first === -1 || last === -1 || last <= first) return null;
|
||
const candidate = text.slice(first, last + 1);
|
||
try {
|
||
return JSON.parse(candidate);
|
||
} catch (e) {
|
||
// 尝试修正全角引号
|
||
const normalized = candidate.replace(/[“”]/g, '"');
|
||
try { return JSON.parse(normalized); } catch { return null; }
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 生成唯一请求ID
|
||
*/
|
||
/**
|
||
* 生成唯一请求ID
|
||
* 格式: 请求类型_服务类型(可选)_NodeID_四位时间戳
|
||
*/
|
||
static generateRequestId(type, serviceType = null, nodeId = '0') {
|
||
const timestamp = Math.floor(Date.now() / 1000).toString().slice(-4);
|
||
const parts = [type];
|
||
if (serviceType) {
|
||
parts.push(serviceType);
|
||
}
|
||
parts.push(nodeId);
|
||
parts.push(timestamp);
|
||
return parts.join('_');
|
||
}
|
||
|
||
/**
|
||
* 取消一个正在进行的请求
|
||
*/
|
||
static async cancelRequest(requestId) {
|
||
if (!requestId) return { success: false, error: "缺少requestId" };
|
||
|
||
const controller = runningRequests.get(requestId);
|
||
|
||
if (controller) {
|
||
// 1. 中止前端的fetch请求
|
||
controller.abort();
|
||
runningRequests.delete(requestId);
|
||
logger.debug(`前端请求已中止 | ID: ${requestId}`);
|
||
}
|
||
|
||
// 2. 通知后端取消任务
|
||
try {
|
||
const apiUrl = this.getApiUrl('request/cancel');
|
||
const response = await fetch(apiUrl, {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify({ request_id: requestId })
|
||
});
|
||
const result = await response.json();
|
||
logger.debug(`后端任务取消请求已发送 | ID: ${requestId} | 结果: ${JSON.stringify(result)}`);
|
||
return result;
|
||
} catch (error) {
|
||
logger.error(`后端任务取消请求失败 | ID: ${requestId} | 错误: ${error.message}`);
|
||
return { success: false, error: error.message };
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 百度翻译API
|
||
*/
|
||
static async baiduTranslate(text, from = 'auto', to = 'zh', request_id = null, is_auto = false) {
|
||
// 生成请求ID
|
||
// 生成请求ID
|
||
if (!request_id) {
|
||
request_id = this.generateRequestId('trans', 'baidu');
|
||
}
|
||
|
||
const controller = new AbortController();
|
||
const signal = controller.signal;
|
||
runningRequests.set(request_id, controller);
|
||
|
||
try {
|
||
if (!text || text.trim() === '') {
|
||
throw new Error('待翻译文本不能为空');
|
||
}
|
||
|
||
// 获取API URL
|
||
const apiUrl = this.getApiUrl('baidu/translate');
|
||
|
||
// 调用后端API
|
||
const response = await fetch(apiUrl, {
|
||
method: 'POST',
|
||
headers: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
body: JSON.stringify({
|
||
text,
|
||
from,
|
||
to,
|
||
request_id,
|
||
is_auto
|
||
}),
|
||
signal // 传递signal
|
||
});
|
||
|
||
const result = await response.json();
|
||
return result;
|
||
} catch (error) {
|
||
if (error.name === 'AbortError') {
|
||
logger.debug(`百度翻译请求被用户中止 | ID: ${request_id}`);
|
||
return { success: false, error: '请求已取消', cancelled: true };
|
||
}
|
||
return {
|
||
success: false,
|
||
error: error.message
|
||
};
|
||
} finally {
|
||
// 请求完成后从Map中移除
|
||
if (runningRequests.has(request_id)) {
|
||
runningRequests.delete(request_id);
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 批量翻译
|
||
*/
|
||
static async batchBaiduTranslate(texts, from = 'auto', to = 'zh') {
|
||
try {
|
||
if (!Array.isArray(texts) || texts.length === 0) {
|
||
throw new Error('待翻译文本数组不能为空');
|
||
}
|
||
|
||
// 串行处理每个文本的翻译
|
||
const results = [];
|
||
for (const text of texts) {
|
||
const result = await this.baiduTranslate(text, from, to);
|
||
results.push(result);
|
||
}
|
||
|
||
return results;
|
||
} catch (error) {
|
||
logger.error(`批量翻译 | 结果:失败 | 错误:${error.message}`);
|
||
return [];
|
||
}
|
||
}
|
||
|
||
/**
|
||
* LLM扩写提示词
|
||
*/
|
||
static async llmExpandPrompt(prompt, request_id = null) {
|
||
// 生成请求ID
|
||
// 生成请求ID
|
||
if (!request_id) {
|
||
request_id = this.generateRequestId('exp');
|
||
}
|
||
|
||
const controller = new AbortController();
|
||
const signal = controller.signal;
|
||
runningRequests.set(request_id, controller);
|
||
|
||
try {
|
||
if (!prompt || prompt.trim() === '') {
|
||
throw new Error('请输入要优化的提示词');
|
||
}
|
||
|
||
logger.debug(`发起LLM提示词优化请求 | 请求ID:${request_id} | 原文:${prompt}`);
|
||
|
||
// 调用后端API
|
||
const apiUrl = this.getApiUrl('llm/expand');
|
||
logger.debug('LLM提示词优化API URL:', apiUrl);
|
||
|
||
const response = await fetch(apiUrl, {
|
||
method: 'POST',
|
||
headers: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
body: JSON.stringify({
|
||
prompt,
|
||
request_id
|
||
}),
|
||
signal // 传递signal
|
||
});
|
||
|
||
const result = await response.json();
|
||
logger.debug(`LLM提示词优化请求成功 | 请求ID:${request_id} | 结果:${JSON.stringify(result)}`);
|
||
|
||
return result;
|
||
} catch (error) {
|
||
if (error.name === 'AbortError') {
|
||
logger.debug(`LLM提示词优化请求被用户中止 | ID: ${request_id}`);
|
||
return { success: false, error: '请求已取消', cancelled: true };
|
||
}
|
||
logger.error(`LLM提示词优化请求失败 | 请求ID:${request_id || 'unknown'} | 错误:${error.message}`);
|
||
return {
|
||
success: false,
|
||
error: error.message
|
||
};
|
||
} finally {
|
||
// 请求完成后从Map中移除
|
||
if (runningRequests.has(request_id)) {
|
||
runningRequests.delete(request_id);
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* LLM翻译文本
|
||
*/
|
||
static async llmTranslate(text, from = 'auto', to = 'zh', request_id = null, is_auto = false) {
|
||
// 生成请求ID
|
||
// 生成请求ID
|
||
if (!request_id) {
|
||
request_id = this.generateRequestId('trans', 'llm');
|
||
}
|
||
|
||
const controller = new AbortController();
|
||
const signal = controller.signal;
|
||
runningRequests.set(request_id, controller);
|
||
|
||
try {
|
||
if (!text || text.trim() === '') {
|
||
throw new Error('请输入要翻译的内容');
|
||
}
|
||
|
||
// 调用后端API
|
||
const apiUrl = this.getApiUrl('llm/translate');
|
||
|
||
const response = await fetch(apiUrl, {
|
||
method: 'POST',
|
||
headers: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
body: JSON.stringify({
|
||
text,
|
||
from,
|
||
to,
|
||
request_id,
|
||
is_auto
|
||
}),
|
||
signal // 传递signal
|
||
});
|
||
|
||
const result = await response.json();
|
||
return result;
|
||
} catch (error) {
|
||
if (error.name === 'AbortError') {
|
||
logger.debug(`LLM翻译请求被用户中止 | ID: ${request_id}`);
|
||
return { success: false, error: '请求已取消', cancelled: true };
|
||
}
|
||
return {
|
||
success: false,
|
||
error: error.message
|
||
};
|
||
} finally {
|
||
// 请求完成后从Map中移除
|
||
if (runningRequests.has(request_id)) {
|
||
runningRequests.delete(request_id);
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 调用视觉模型分析图像
|
||
*/
|
||
static async llmAnalyzeImage(imageData, prompt, request_id = null) {
|
||
// 生成请求ID
|
||
// 生成请求ID
|
||
if (!request_id) {
|
||
request_id = this.generateRequestId('icap');
|
||
}
|
||
|
||
const controller = new AbortController();
|
||
const signal = controller.signal;
|
||
runningRequests.set(request_id, controller);
|
||
|
||
try {
|
||
if (!imageData) {
|
||
throw new Error('未找到有效的图像');
|
||
}
|
||
|
||
logger.debug(`发起视觉分析请求 | 请求ID:${request_id}`);
|
||
|
||
// 构建API URL
|
||
const apiUrl = this.getApiUrl('vlm/analyze');
|
||
logger.debug('视觉分析API URL:', apiUrl);
|
||
|
||
// 构建请求数据
|
||
const requestData = {
|
||
image: imageData,
|
||
prompt: prompt, // 添加prompt
|
||
request_id: request_id
|
||
};
|
||
|
||
// 发送请求
|
||
const response = await fetch(apiUrl, {
|
||
method: 'POST',
|
||
headers: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
body: JSON.stringify(requestData),
|
||
signal // 传递signal
|
||
});
|
||
|
||
// 解析响应
|
||
const result = await response.json();
|
||
logger.debug(`视觉分析请求完成 | 请求ID:${request_id}`);
|
||
|
||
return result;
|
||
} catch (error) {
|
||
if (error.name === 'AbortError') {
|
||
logger.debug(`视觉分析请求被用户中止 | ID: ${request_id}`);
|
||
return { success: false, error: '请求已取消', cancelled: true };
|
||
}
|
||
logger.error(`视觉分析请求失败 | 请求ID:${request_id || 'unknown'} | 错误:${error.message}`);
|
||
return {
|
||
success: false,
|
||
error: error.message || '请求失败'
|
||
};
|
||
} finally {
|
||
// 请求完成后从Map中移除
|
||
if (runningRequests.has(request_id)) {
|
||
runningRequests.delete(request_id);
|
||
}
|
||
}
|
||
}
|
||
|
||
// ---流式输出API方法（SSE）---
|
||
|
||
/**
|
||
* 流式视觉分析图像
|
||
* 使用 SSE 逐 token 接收分析结果
|
||
* @param {string} imageData - Base64 编码的图像数据
|
||
* @param {string} prompt - 分析提示词
|
||
* @param {string} request_id - 请求ID
|
||
* @param {Function} onChunk - 接收每个 chunk 的回调函数
|
||
* @returns {Promise<Object>} - 完整的分析结果
|
||
*/
|
||
static async llmAnalyzeImageStream(imageData, prompt, request_id = null, onChunk = null) {
|
||
if (!request_id) {
|
||
request_id = this.generateRequestId('icap');
|
||
}
|
||
|
||
const controller = new AbortController();
|
||
const signal = controller.signal;
|
||
runningRequests.set(request_id, controller);
|
||
|
||
try {
|
||
if (!imageData) {
|
||
throw new Error('未找到有效的图像');
|
||
}
|
||
|
||
logger.debug(`发起流式视觉分析请求 | 请求ID:${request_id}`);
|
||
|
||
const apiUrl = this.getApiUrl('vlm/analyze/stream');
|
||
const requestData = {
|
||
image: imageData,
|
||
prompt: prompt,
|
||
request_id: request_id
|
||
};
|
||
|
||
const response = await fetch(apiUrl, {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify(requestData),
|
||
signal
|
||
});
|
||
|
||
if (!response.ok) {
|
||
throw new Error(`HTTP error! status: ${response.status}`);
|
||
}
|
||
|
||
const reader = response.body.getReader();
|
||
const decoder = new TextDecoder();
|
||
let buffer = '';
|
||
let finalResult = null;
|
||
|
||
while (true) {
|
||
const { done, value } = await reader.read();
|
||
if (done) break;
|
||
|
||
buffer += decoder.decode(value, { stream: true });
|
||
const lines = buffer.split('\n');
|
||
buffer = lines.pop() || '';
|
||
|
||
for (const line of lines) {
|
||
if (line.startsWith('data: ')) {
|
||
try {
|
||
const data = JSON.parse(line.slice(6));
|
||
if (data.chunk && onChunk) {
|
||
onChunk(data.chunk);
|
||
}
|
||
if (data.done) {
|
||
finalResult = data.result;
|
||
}
|
||
if (data.error) {
|
||
throw new Error(data.error);
|
||
}
|
||
} catch (parseError) {
|
||
if (parseError.message !== 'Unexpected end of JSON input') {
|
||
logger.warn(`解析 SSE 数据失败: ${parseError.message}`);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
logger.debug(`流式视觉分析请求完成 | 请求ID:${request_id}`);
|
||
return finalResult;
|
||
|
||
} catch (error) {
|
||
if (error.name === 'AbortError') {
|
||
logger.debug(`流式视觉分析请求被用户中止 | ID: ${request_id}`);
|
||
return { success: false, error: '请求已取消', cancelled: true };
|
||
}
|
||
logger.error(`流式视觉分析请求失败 | 请求ID:${request_id || 'unknown'} | 错误:${error.message}`);
|
||
return { success: false, error: error.message || '请求失败' };
|
||
} finally {
|
||
if (runningRequests.has(request_id)) {
|
||
runningRequests.delete(request_id);
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 流式LLM扩写提示词
|
||
* 使用 SSE 逐 token 接收扩写结果
|
||
* @param {string} prompt - 要扩写的提示词
|
||
* @param {string} request_id - 请求ID
|
||
* @param {Function} onChunk - 接收每个 chunk 的回调函数
|
||
* @returns {Promise<Object>} - 完整的扩写结果
|
||
*/
|
||
static async llmExpandPromptStream(prompt, request_id = null, onChunk = null) {
|
||
if (!request_id) {
|
||
request_id = this.generateRequestId('exp');
|
||
}
|
||
|
||
const controller = new AbortController();
|
||
const signal = controller.signal;
|
||
runningRequests.set(request_id, controller);
|
||
|
||
try {
|
||
if (!prompt || prompt.trim() === '') {
|
||
throw new Error('请输入要优化的提示词');
|
||
}
|
||
|
||
logger.debug(`发起流式LLM提示词优化请求 | 请求ID:${request_id}`);
|
||
|
||
const apiUrl = this.getApiUrl('llm/expand/stream');
|
||
|
||
const response = await fetch(apiUrl, {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify({ prompt, request_id }),
|
||
signal
|
||
});
|
||
|
||
if (!response.ok) {
|
||
throw new Error(`HTTP error! status: ${response.status}`);
|
||
}
|
||
|
||
const reader = response.body.getReader();
|
||
const decoder = new TextDecoder();
|
||
let buffer = '';
|
||
let finalResult = null;
|
||
|
||
while (true) {
|
||
const { done, value } = await reader.read();
|
||
if (done) break;
|
||
|
||
buffer += decoder.decode(value, { stream: true });
|
||
const lines = buffer.split('\n');
|
||
buffer = lines.pop() || '';
|
||
|
||
for (const line of lines) {
|
||
if (line.startsWith('data: ')) {
|
||
try {
|
||
const data = JSON.parse(line.slice(6));
|
||
if (data.chunk && onChunk) {
|
||
onChunk(data.chunk);
|
||
}
|
||
if (data.done) {
|
||
finalResult = data.result;
|
||
}
|
||
if (data.error) {
|
||
throw new Error(data.error);
|
||
}
|
||
} catch (parseError) {
|
||
if (parseError.message !== 'Unexpected end of JSON input') {
|
||
logger.warn(`解析 SSE 数据失败: ${parseError.message}`);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
logger.debug(`流式LLM提示词优化请求完成 | 请求ID:${request_id}`);
|
||
return finalResult;
|
||
|
||
} catch (error) {
|
||
if (error.name === 'AbortError') {
|
||
logger.debug(`流式LLM提示词优化请求被用户中止 | ID: ${request_id}`);
|
||
return { success: false, error: '请求已取消', cancelled: true };
|
||
}
|
||
logger.error(`流式LLM提示词优化请求失败 | 请求ID:${request_id || 'unknown'} | 错误:${error.message}`);
|
||
return { success: false, error: error.message };
|
||
} finally {
|
||
if (runningRequests.has(request_id)) {
|
||
runningRequests.delete(request_id);
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 流式LLM翻译
|
||
* 使用 SSE 逐 token 接收翻译结果
|
||
* 注意：仅支持LLM翻译服务，百度翻译不支持流式
|
||
* @param {string} text - 要翻译的文本
|
||
* @param {string} fromLang - 源语言
|
||
* @param {string} toLang - 目标语言
|
||
* @param {string} request_id - 请求ID
|
||
* @param {Function} onChunk - 接收每个 chunk 的回调函数
|
||
* @returns {Promise<Object>} - 完整的翻译结果
|
||
*/
|
||
static async llmTranslateStream(text, fromLang, toLang, request_id = null, onChunk = null) {
|
||
if (!request_id) {
|
||
request_id = this.generateRequestId('trans');
|
||
}
|
||
|
||
const controller = new AbortController();
|
||
const signal = controller.signal;
|
||
runningRequests.set(request_id, controller);
|
||
|
||
try {
|
||
if (!text || text.trim() === '') {
|
||
throw new Error('请输入要翻译的内容');
|
||
}
|
||
|
||
logger.debug(`发起流式LLM翻译请求 | 请求ID:${request_id} | ${fromLang}→${toLang}`);
|
||
|
||
const apiUrl = this.getApiUrl('llm/translate/stream');
|
||
|
||
const response = await fetch(apiUrl, {
|
||
method: 'POST',
|
||
headers: { 'Content-Type': 'application/json' },
|
||
body: JSON.stringify({
|
||
text,
|
||
from: fromLang,
|
||
to: toLang,
|
||
request_id
|
||
}),
|
||
signal
|
||
});
|
||
|
||
if (!response.ok) {
|
||
throw new Error(`HTTP error! status: ${response.status}`);
|
||
}
|
||
|
||
const reader = response.body.getReader();
|
||
const decoder = new TextDecoder();
|
||
let buffer = '';
|
||
let finalResult = null;
|
||
|
||
while (true) {
|
||
const { done, value } = await reader.read();
|
||
if (done) break;
|
||
|
||
buffer += decoder.decode(value, { stream: true });
|
||
const lines = buffer.split('\n');
|
||
buffer = lines.pop() || '';
|
||
|
||
for (const line of lines) {
|
||
if (line.startsWith('data: ')) {
|
||
try {
|
||
const data = JSON.parse(line.slice(6));
|
||
if (data.chunk && onChunk) {
|
||
onChunk(data.chunk);
|
||
}
|
||
if (data.done) {
|
||
finalResult = data.result;
|
||
}
|
||
if (data.error) {
|
||
throw new Error(data.error);
|
||
}
|
||
} catch (parseError) {
|
||
if (parseError.message !== 'Unexpected end of JSON input') {
|
||
logger.warn(`解析 SSE 数据失败: ${parseError.message}`);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
logger.debug(`流式LLM翻译请求完成 | 请求ID:${request_id}`);
|
||
return finalResult;
|
||
|
||
} catch (error) {
|
||
if (error.name === 'AbortError') {
|
||
logger.debug(`流式LLM翻译请求被用户中止 | ID: ${request_id}`);
|
||
return { success: false, error: '请求已取消', cancelled: true };
|
||
}
|
||
logger.error(`流式LLM翻译请求失败 | 请求ID:${request_id || 'unknown'} | 错误:${error.message}`);
|
||
return { success: false, error: error.message };
|
||
} finally {
|
||
if (runningRequests.has(request_id)) {
|
||
runningRequests.delete(request_id);
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 将图像转换为Base64
|
||
*/
|
||
static async imageToBase64(img) {
|
||
return new Promise((resolve, reject) => {
|
||
try {
|
||
if (!img) {
|
||
reject('无效的图像');
|
||
return;
|
||
}
|
||
|
||
// 如果已经是base64字符串，直接返回
|
||
if (typeof img === 'string' && img.startsWith('data:image')) {
|
||
resolve(img);
|
||
return;
|
||
}
|
||
|
||
// 如果是Blob对象
|
||
if (img instanceof Blob) {
|
||
const reader = new FileReader();
|
||
reader.onload = () => resolve(reader.result);
|
||
reader.onerror = reject;
|
||
reader.readAsDataURL(img);
|
||
return;
|
||
}
|
||
|
||
// 如果是URL
|
||
if (typeof img === 'string' && (img.startsWith('http') || img.startsWith('/'))) {
|
||
const image = new Image();
|
||
image.crossOrigin = 'Anonymous';
|
||
image.onload = () => {
|
||
const canvas = document.createElement('canvas');
|
||
canvas.width = image.width;
|
||
canvas.height = image.height;
|
||
const ctx = canvas.getContext('2d');
|
||
ctx.drawImage(image, 0, 0);
|
||
resolve(canvas.toDataURL('image/jpeg'));
|
||
};
|
||
image.onerror = () => reject('图像加载失败');
|
||
image.src = img;
|
||
return;
|
||
}
|
||
|
||
// 处理ComfyUI图像对象
|
||
if (img && typeof img === 'object' && img.src) {
|
||
// 如果图像对象有src属性，使用它
|
||
const image = new Image();
|
||
image.crossOrigin = 'Anonymous';
|
||
image.onload = () => {
|
||
const canvas = document.createElement('canvas');
|
||
canvas.width = image.width;
|
||
canvas.height = image.height;
|
||
const ctx = canvas.getContext('2d');
|
||
ctx.drawImage(image, 0, 0);
|
||
resolve(canvas.toDataURL('image/jpeg'));
|
||
};
|
||
image.onerror = (e) => {
|
||
console.error('图像加载失败:', e);
|
||
reject('图像加载失败');
|
||
};
|
||
image.src = img.src;
|
||
return;
|
||
}
|
||
|
||
// 处理HTMLImageElement或类似的对象
|
||
if (img && (img instanceof HTMLImageElement || (img.width && img.height && img.complete))) {
|
||
try {
|
||
const canvas = document.createElement('canvas');
|
||
canvas.width = img.width;
|
||
canvas.height = img.height;
|
||
const ctx = canvas.getContext('2d');
|
||
ctx.drawImage(img, 0, 0);
|
||
resolve(canvas.toDataURL('image/jpeg'));
|
||
return;
|
||
} catch (e) {
|
||
console.warn('使用canvas转换图像失败:', e);
|
||
// 继续尝试其他方法
|
||
}
|
||
}
|
||
|
||
// 处理ComfyUI的特殊格式 (dataURL缓存在node中)
|
||
if (img && img.dataURL) {
|
||
resolve(img.dataURL);
|
||
return;
|
||
}
|
||
|
||
// 处理ComfyUI特殊的图像数据格式
|
||
if (img && img.data && img.width && img.height) {
|
||
try {
|
||
const canvas = document.createElement('canvas');
|
||
canvas.width = img.width;
|
||
canvas.height = img.height;
|
||
const ctx = canvas.getContext('2d');
|
||
const imageData = new ImageData(
|
||
new Uint8ClampedArray(img.data.buffer || img.data),
|
||
img.width,
|
||
img.height
|
||
);
|
||
ctx.putImageData(imageData, 0, 0);
|
||
resolve(canvas.toDataURL('image/jpeg'));
|
||
return;
|
||
} catch (e) {
|
||
console.error('处理图像数据失败:', e);
|
||
}
|
||
}
|
||
|
||
console.error('不支持的图像格式', img);
|
||
reject('不支持的图像格式');
|
||
} catch (error) {
|
||
console.error('转换图像出错:', error);
|
||
reject(error);
|
||
}
|
||
});
|
||
}
|
||
}
|
||
|
||
export { APIService };
|