koishi-plugin-video-parser-all 1.0.6 → 1.0.8

package/lib/index.d.ts

@@ -25,6 +25,14 @@ export declare const Config: Schema<{
     retryInterval?: number | null | undefined;
 } & {
     enableForward?: boolean | null | undefined;
+} & {
+    primaryApiUrl?: string | null | undefined;
+    backupApiUrl?: string | null | undefined;
+    useDedicatedApiFirst?: boolean | null | undefined;
+    customApis?: ({
+        platform?: "bilibili" | "douyin" | "kuaishou" | "xiaohongshu" | "weibo" | "xigua" | "youtube" | "tiktok" | "acfun" | "zhihu" | "weishi" | "huya" | "haokan" | "meipai" | "twitter" | "instagram" | "doubao" | null | undefined;
+        apiUrl?: string | null | undefined;
+    } & import("cosmokit").Dict)[] | null | undefined;
 } & {
     waitingTipText?: string | null | undefined;
     unsupportedPlatformText?: string | null | undefined;
@@ -56,6 +64,14 @@ export declare const Config: Schema<{
     retryInterval: number;
 } & {
     enableForward: boolean;
+} & {
+    primaryApiUrl: string;
+    backupApiUrl: string;
+    useDedicatedApiFirst: boolean;
+    customApis: Schemastery.ObjectT<{
+        platform: Schema<"bilibili" | "douyin" | "kuaishou" | "xiaohongshu" | "weibo" | "xigua" | "youtube" | "tiktok" | "acfun" | "zhihu" | "weishi" | "huya" | "haokan" | "meipai" | "twitter" | "instagram" | "doubao", "bilibili" | "douyin" | "kuaishou" | "xiaohongshu" | "weibo" | "xigua" | "youtube" | "tiktok" | "acfun" | "zhihu" | "weishi" | "huya" | "haokan" | "meipai" | "twitter" | "instagram" | "doubao">;
+        apiUrl: Schema<string, string>;
+    }>[];
 } & {
     waitingTipText: string;
     unsupportedPlatformText: string;

package/lib/index.js

@@ -45,6 +45,33 @@ exports.Config = koishi_1.Schema.intersect([
     koishi_1.Schema.object({
         enableForward: koishi_1.Schema.boolean().default(false).description('启用合并转发（仅 OneBot 平台）'),
     }).description('发送方式设置'),
+    koishi_1.Schema.object({
+        primaryApiUrl: koishi_1.Schema.string().default('https://api.bugpk.com/api/short_videos').description('主 API 地址'),
+        backupApiUrl: koishi_1.Schema.string().default('https://api.bugpk.com/api/svparse').description('备用主 API 地址（仅支持抖音/小红书/ins/即梦）'),
+        useDedicatedApiFirst: koishi_1.Schema.boolean().default(false).description('优先使用平台专属 API，失败后回退到通用 API'),
+        customApis: koishi_1.Schema.array(koishi_1.Schema.object({
+            platform: koishi_1.Schema.union([
+                'bilibili',
+                'douyin',
+                'kuaishou',
+                'xiaohongshu',
+                'weibo',
+                'xigua',
+                'youtube',
+                'tiktok',
+                'acfun',
+                'zhihu',
+                'weishi',
+                'huya',
+                'haokan',
+                'meipai',
+                'twitter',
+                'instagram',
+                'doubao',
+            ]).description('选择平台'),
+            apiUrl: koishi_1.Schema.string().description('API 地址'),
+        })).default([]).description('自定义平台专属 API，可覆盖默认专属 API'),
+    }).description('API 选择设置'),
     koishi_1.Schema.object({
         waitingTipText: koishi_1.Schema.string().default('正在解析视频，请稍候...').description('解析等待提示'),
         unsupportedPlatformText: koishi_1.Schema.string().default('不支持该平台链接').description('不支持的平台提示'),
@@ -118,98 +145,9 @@ function linkTypeParser(content) {
     }
     return matches;
 }
-function extractUrl(content) {
-    if (!content)
-        return [];
-    const urlMatches = content.match(/https?:\/\/[^\s<>"'(){}[\]]+/gi) || [];
-    return urlMatches.filter(url => {
-        try {
-            const urlObj = new URL(url);
-            const hostname = urlObj.hostname.toLowerCase();
-            if (hostname.includes('multimedia.nt.qq.com.cn') ||
-                hostname.includes('grouptalk.qq.com') ||
-                hostname.includes('qpic.cn') ||
-                hostname.includes('qlogo.cn')) {
-                return false;
-            }
-            if (hostname === 'v.douyin.com' && urlObj.pathname.length < 3)
-                return false;
-            if (hostname === 'www.douyin.com' && urlObj.pathname === '/')
-                return false;
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }).map(url => {
-        return url.replace(/[.,;:!?)]+$/, '');
-    });
-}
 function extractAllUrlsFromMessage(session) {
     const content = session.content?.trim() || '';
-    const urls = [];
-    const linkMatches = linkTypeParser(content);
-    if (linkMatches.length > 0) {
-        for (const match of linkMatches) {
-            urls.push(match.url);
-        }
-        return [...new Set(urls)];
-    }
-    if (content) {
-        const textUrls = extractUrl(content);
-        urls.push(...textUrls);
-    }
-    if (session.elements) {
-        for (const elem of session.elements) {
-            if (elem.type === 'xml' && elem.data) {
-                const urlRegex = /https?:\/\/[^\s<>"'(){}[\]]+/gi;
-                let match;
-                while ((match = urlRegex.exec(elem.data)) !== null) {
-                    const cleanUrl = match[0].replace(/[.,;:!?)]+$/, '');
-                    urls.push(cleanUrl);
-                }
-            }
-            else if (elem.type === 'json' && elem.data) {
-                try {
-                    const json = JSON.parse(elem.data);
-                    const extractFromObject = (obj) => {
-                        if (!obj || typeof obj !== 'object')
-                            return;
-                        for (const val of Object.values(obj)) {
-                            if (typeof val === 'string') {
-                                const match = val.match(/https?:\/\/[^\s<>"'(){}[\]]+/gi);
-                                if (match) {
-                                    match.forEach(url => {
-                                        const cleanUrl = url.replace(/[.,;:!?)]+$/, '');
-                                        urls.push(cleanUrl);
-                                    });
-                                }
-                            }
-                            else if (typeof val === 'object')
-                                extractFromObject(val);
-                        }
-                    };
-                    extractFromObject(json);
-                }
-                catch (e) {
-                    debugLog('WARN', '解析JSON卡片失败:', e);
-                }
-            }
-        }
-    }
-    return [...new Set(urls)].filter(url => {
-        try {
-            const urlObj = new URL(url);
-            if (urlObj.hostname === 'v.douyin.com' && urlObj.pathname.length < 3)
-                return false;
-            if (urlObj.hostname === 'www.douyin.com' && urlObj.pathname === '/')
-                return false;
-            return true;
-        }
-        catch {
-            return false;
-        }
-    });
+    return linkTypeParser(content);
 }
 function cleanUrl(url) {
     try {
@@ -381,10 +319,6 @@ function parseApiResponse(raw, maxDescLen) {
     else if (extra.create_time) {
         publishTime = extra.create_time * 1000;
     }
-    debugLog('DEBUG', '解析后的数据:', {
-        type, title, author, video: video.substring(0, 100) + '...',
-        images: images.length, live_photo: live_photo.length
-    });
     return {
         type, title, desc, author, uid, avatar, cover,
         video, videos, images, live_photo, music,
@@ -534,48 +468,88 @@ function apply(ctx, config) {
             'Content-Type': 'application/x-www-form-urlencoded'
         }
     });
-    async function fetchApi(url) {
+    const defaultDedicatedApis = {
+        bilibili: 'https://api.bugpk.com/api/bilibili',
+        douyin: 'https://api.bugpk.com/api/douyin',
+        doubao: 'https://api.bugpk.com/api/dbvideos',
+        kuaishou: 'https://api.bugpk.com/api/kuaishou',
+        xiaohongshu: 'https://api.bugpk.com/api/xhs',
+        jimeng: 'https://api.bugpk.com/api/jimengai',
+        toutiao: 'https://api.bugpk.com/api/toutiao',
+        weibo: 'https://api.bugpk.com/api/weibo',
+        huya: 'https://api.bugpk.com/api/huya',
+        pipigx: 'https://api.bugpk.com/api/pipigx',
+        pipixia: 'https://api.bugpk.com/api/pipixia',
+        zuiyou: 'https://api.bugpk.com/api/zuiyou',
+    };
+    const backupSupportedPlatforms = new Set(['douyin', 'xiaohongshu', 'instagram', 'jimeng']);
+    function getDedicatedApiUrl(type) {
+        if (config.customApis && Array.isArray(config.customApis)) {
+            const found = config.customApis.find((item) => item.platform === type);
+            if (found && found.apiUrl)
+                return found.apiUrl;
+        }
+        return defaultDedicatedApis[type] || null;
+    }
+    async function fetchApi(url, type) {
         const cacheKey = url;
         const cached = urlCache.get(cacheKey);
         if (cached && cached.expire > Date.now()) {
             debugLog('DEBUG', `使用缓存: ${url}`);
             return cached.data;
         }
-        debugLog('INFO', `调用API解析: ${url}`);
+        const dedicatedApiUrl = getDedicatedApiUrl(type);
+        const primaryApi = config.primaryApiUrl || 'https://api.bugpk.com/api/short_videos';
+        const backupApi = config.backupApiUrl || 'https://api.bugpk.com/api/svparse';
+        const backupAllowed = backupSupportedPlatforms.has(type);
+        const apiList = [];
+        if (config.useDedicatedApiFirst) {
+            if (dedicatedApiUrl)
+                apiList.push({ url: dedicatedApiUrl, label: `专属API(${type})` });
+            apiList.push({ url: primaryApi, label: '默认主API' });
+            if (backupAllowed)
+                apiList.push({ url: backupApi, label: '备用主API' });
+        }
+        else {
+            apiList.push({ url: primaryApi, label: '默认主API' });
+            if (backupAllowed)
+                apiList.push({ url: backupApi, label: '备用主API' });
+            if (dedicatedApiUrl)
+                apiList.push({ url: dedicatedApiUrl, label: `专属API(${type})` });
+        }
         let lastError = null;
-        for (let i = 0; i <= config.retryTimes; i++) {
-            try {
-                const res = await http.get('https://api.bugpk.com/api/short_videos', {
-                    params: { url },
-                    timeout: config.timeout
-                });
-                debugLog('DEBUG', `API响应状态: ${res.status}`);
-                if (res.data && (res.data.code === 200 || res.data.code === 0)) {
-                    const parsed = parseApiResponse(res.data, config.maxDescLength);
-                    urlCache.set(cacheKey, {
-                        data: parsed,
-                        expire: Date.now() + 10 * 60 * 1000
+        for (const api of apiList) {
+            for (let attempt = 0; attempt <= config.retryTimes; attempt++) {
+                try {
+                    const res = await http.get(api.url, {
+                        params: { url },
+                        timeout: config.timeout
                     });
-                    return parsed;
+                    if (res.data && (res.data.code === 200 || res.data.code === 0)) {
+                        const parsed = parseApiResponse(res.data, config.maxDescLength);
+                        urlCache.set(cacheKey, { data: parsed, expire: Date.now() + 10 * 60 * 1000 });
+                        return parsed;
+                    }
+                    throw new Error(res.data?.msg || `API返回错误码: ${res.data?.code}`);
                 }
-                throw new Error(res.data?.msg || `API返回错误码: ${res.data?.code}`);
-            }
-            catch (error) {
-                lastError = error instanceof Error ? error : new Error(String(error));
-                debugLog('ERROR', `第${i + 1}次请求失败: ${lastError.message}`);
-                if (i < config.retryTimes) {
-                    await delay(config.retryInterval);
+                catch (error) {
+                    lastError = error instanceof Error ? error : new Error(String(error));
+                    debugLog('ERROR', `${api.label} 第${attempt + 1}次请求失败: ${lastError.message}`);
+                    if (attempt < config.retryTimes) {
+                        await delay(config.retryInterval);
+                    }
                 }
             }
+            debugLog('WARN', `${api.label} 所有重试均失败，切换下一个API`);
         }
-        throw lastError || new Error('API请求全部失败');
+        throw lastError || new Error('所有API请求全部失败');
     }
-    async function parseUrl(url) {
+    async function parseUrl(url, type) {
         const realUrl = await resolveShortUrl(url);
         const candidates = [realUrl, url];
         for (const candidate of [...new Set(candidates)]) {
             try {
-                const info = await fetchApi(candidate);
+                const info = await fetchApi(candidate, type);
                 if (info.video || info.images.length > 0) {
                     return { success: true, data: info };
                 }
@@ -587,8 +561,8 @@ function apply(ctx, config) {
         }
         return { success: false, msg: texts.unsupportedPlatformText };
     }
-    async function processSingleUrl(url) {
-        const result = await parseUrl(url);
+    async function processSingleUrl(url, type) {
+        const result = await parseUrl(url, type);
         if (!result.success) {
             return { success: false, msg: result.msg, url };
         }
@@ -641,72 +615,70 @@ function apply(ctx, config) {
     }
     async function sendVideoFile(session, videoUrl) {
         if (!videoUrl)
-            throw new Error('视频链接为空');
+            return;
         if (!config.showVideoFile) {
             return await sendWithTimeout(session, `视频链接：${videoUrl}`);
         }
-        const sendLinkAsFallback = async () => {
+        const sendLink = async () => {
             await sendWithTimeout(session, `视频链接：${videoUrl}`).catch(() => { });
         };
-        const tryDownloadAndSend = async () => {
-            let tempFilePath = null;
+        if (config.forceDownloadVideo) {
             try {
-                tempFilePath = await downloadVideoFile(videoUrl, config.tempDir || './temp_videos', config.videoDownloadTimeout || 120000, config.maxVideoSize || 0);
+                const tempFilePath = await downloadVideoFile(videoUrl, config.tempDir || './temp_videos', config.videoDownloadTimeout || 120000, config.maxVideoSize || 0);
                 const localFile = `file://${tempFilePath}`;
-                debugLog('INFO', `发送本地视频文件: ${localFile}`);
-                return await sendWithTimeout(session, koishi_1.h.video(localFile));
+                await sendWithTimeout(session, koishi_1.h.video(localFile));
+                return;
             }
-            finally {
-                if (tempFilePath) {
-                    promises_1.default.unlink(tempFilePath).catch(e => debugLog('WARN', `删除临时文件失败: ${e}`));
+            catch (e) {
+                debugLog('ERROR', '强制下载失败，尝试直接发送URL:', getErrorMessage(e));
+                try {
+                    await sendWithTimeout(session, koishi_1.h.video(videoUrl));
+                    return;
+                }
+                catch (urlErr) {
+                    debugLog('ERROR', '发送URL也失败，降级发送链接:', getErrorMessage(urlErr));
+                    await sendLink();
                 }
             }
-        };
-        if (config.forceDownloadVideo) {
-            try {
-                return await tryDownloadAndSend();
-            }
-            catch (err) {
-                debugLog('ERROR', `下载并发送视频失败: ${getErrorMessage(err)}`);
-                await sendLinkAsFallback();
-            }
+            return;
         }
-        else {
+        try {
+            debugLog('INFO', '尝试直接发送视频URL');
+            await sendWithTimeout(session, koishi_1.h.video(videoUrl));
+            return;
+        }
+        catch (urlErr) {
+            debugLog('ERROR', '直接发送URL失败，尝试下载:', getErrorMessage(urlErr));
             try {
-                debugLog('INFO', `尝试直接发送视频URL: ${videoUrl.substring(0, 100)}...`);
-                return await sendWithTimeout(session, koishi_1.h.video(videoUrl));
+                const tempFilePath = await downloadVideoFile(videoUrl, config.tempDir || './temp_videos', config.videoDownloadTimeout || 120000, config.maxVideoSize || 0);
+                const localFile = `file://${tempFilePath}`;
+                await sendWithTimeout(session, koishi_1.h.video(localFile));
+                return;
             }
-            catch (err) {
-                debugLog('ERROR', `直接发送URL失败，尝试下载: ${getErrorMessage(err)}`);
-                try {
-                    return await tryDownloadAndSend();
-                }
-                catch (downloadErr) {
-                    debugLog('ERROR', `下载并发送视频也失败: ${getErrorMessage(downloadErr)}`);
-                    await sendLinkAsFallback();
-                }
+            catch (downloadErr) {
+                debugLog('ERROR', '下载失败，降级发送链接:', getErrorMessage(downloadErr));
+                await sendLink();
             }
         }
     }
-    async function flush(session, urls) {
-        const uniqueUrls = [...new Set(urls)];
-        debugLog('INFO', `开始解析 ${uniqueUrls.length} 个链接`);
+    async function flush(session, matches) {
+        debugLog('INFO', `开始解析 ${matches.length} 个链接`);
         const items = [];
         const errors = [];
-        for (let i = 0; i < uniqueUrls.length; i++) {
-            const url = uniqueUrls[i];
-            debugLog('INFO', `正在解析第 ${i + 1}/${uniqueUrls.length} 个链接: ${url}`);
-            const result = await processSingleUrl(url);
+        for (let i = 0; i < matches.length; i++) {
+            const match = matches[i];
+            debugLog('INFO', `正在解析第 ${i + 1}/${matches.length} 个链接: ${match.url} (平台: ${match.type})`);
+            const result = await processSingleUrl(match.url, match.type);
             if (result.success) {
                 items.push(result.data);
             }
             else {
                 const item = texts.parseErrorItemFormat
-                    .replace(/\$\{url\}/g, url.length > 50 ? url.slice(0, 50) + '...' : url)
+                    .replace(/\$\{url\}/g, match.url.length > 50 ? match.url.slice(0, 50) + '...' : match.url)
                     .replace(/\$\{msg\}/g, result.msg);
                 errors.push(item);
             }
-            if (i < uniqueUrls.length - 1) {
+            if (i < matches.length - 1) {
                 await delay(500);
             }
         }
@@ -718,24 +690,6 @@ function apply(ctx, config) {
             debugLog('INFO', '没有成功解析的内容');
             return;
         }
-        // 先发送所有视频（单独发送，在合并转发之前）
-        for (const item of items) {
-            const p = item.parsed;
-            if (p.video && (p.type === 'video' || (p.type === 'live' && !p.live_photo?.length && !p.images?.length))) {
-                if (config.showVideoFile) {
-                    try {
-                        await sendVideoFile(session, p.video);
-                    }
-                    catch (e) {
-                        debugLog('ERROR', `视频发送失败: ${getErrorMessage(e)}`);
-                    }
-                }
-                else {
-                    await sendWithTimeout(session, `视频链接：${p.video}`);
-                }
-                await delay(500);
-            }
-        }
         const enableForward = config.enableForward && session.platform === 'onebot';
         const botName = config.botName || '视频解析机器人';
         if (enableForward) {
@@ -755,7 +709,9 @@ function apply(ctx, config) {
                         forwardMessages.push(buildForwardNode(session, koishi_1.h.image(imgUrl), botName));
                     }
                 }
-                // 视频已单独发送，合并转发中不再添加
+                if (p.video) {
+                    forwardMessages.push(buildForwardNode(session, koishi_1.h.video(p.video), botName));
+                }
             }
             if (forwardMessages.length) {
                 const forwardMsg = (0, koishi_1.h)('message', { forward: true }, forwardMessages.slice(0, 100));
@@ -773,7 +729,6 @@ function apply(ctx, config) {
             }
         }
         else {
-            // 非合并转发，只发送文字、封面、图片（视频已在之前发过）
             for (const item of items) {
                 const p = item.parsed;
                 const text = item.text;
@@ -785,6 +740,20 @@ function apply(ctx, config) {
                     await sendWithTimeout(session, koishi_1.h.image(p.cover)).catch(() => { });
                     await delay(300);
                 }
+                if (p.video && (p.type === 'video' || (p.type === 'live' && !p.live_photo?.length && !p.images?.length))) {
+                    if (config.showVideoFile) {
+                        try {
+                            await sendVideoFile(session, p.video);
+                        }
+                        catch (e) {
+                            debugLog('ERROR', `视频发送失败: ${getErrorMessage(e)}`);
+                        }
+                    }
+                    else {
+                        await sendWithTimeout(session, `视频链接：${p.video}`);
+                    }
+                    await delay(500);
+                }
                 if (p.type === 'image' || p.type === 'live_photo' || (p.type === 'live' && (p.live_photo?.length || p.images?.length))) {
                     const imageUrls = p.images?.length ? p.images : (p.live_photo?.map(lp => lp.image) ?? []);
                     for (const imgUrl of imageUrls) {
@@ -805,10 +774,10 @@ function apply(ctx, config) {
             return;
         if (session.selfId === session.userId)
             return;
-        const urls = extractAllUrlsFromMessage(session);
-        if (!urls.length)
+        const matches = extractAllUrlsFromMessage(session);
+        if (!matches.length)
             return;
-        debugLog('INFO', `检测到 ${urls.length} 个链接，开始处理`);
+        debugLog('INFO', `检测到 ${matches.length} 个链接，开始处理`);
         if (config.showWaitingTip) {
             try {
                 await sendWithTimeout(session, texts.waitingTipText);
@@ -817,15 +786,15 @@ function apply(ctx, config) {
                 debugLog('WARN', '发送等待提示失败:', e);
             }
         }
-        await flush(session, urls);
+        await flush(session, matches);
     });
     ctx.command('parse <url>', '手动解析视频').action(async ({ session }, url) => {
         if (!url) {
             await sendWithTimeout(session, texts.invalidLinkText);
             return;
         }
-        const us = extractUrl(url);
-        if (!us.length) {
+        const matches = linkTypeParser(url);
+        if (!matches.length) {
             await sendWithTimeout(session, texts.invalidLinkText);
             return;
         }
@@ -835,7 +804,7 @@ function apply(ctx, config) {
             }
             catch { }
         }
-        await flush(session, us);
+        await flush(session, matches);
     });
     const tempCleanupInterval = setInterval(async () => {
         try {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-video-parser-all",
   "description": "Koishi 全平台视频解析插件，支持抖音/快手/B站/微博/小红书/剪映/YouTube/TikTok等20+平台",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "files": [
@@ -76,4 +76,4 @@
   "engines": {
     "node": ">=16.0.0"
   }
-}
+}

package/readme.md

@@ -3,30 +3,10 @@
 ## 项目介绍 (Project Introduction)
 
 ### 中文
-这是一个为 Koishi 机器人框架开发的**全平台视频/图集解析插件**，使用统一API接口，支持自动识别并解析抖音、快手、B站、小红书、微博、YouTube、TikTok、剪映、AcFun、知乎、虎牙等20+主流平台的短视频/图集/实况链接。核心特性：
-- 🌐 统一API解析，覆盖20+热门平台，无需繁琐配置
-- 🤖 自动识别链接来源，即丢即用，并支持解析 XML/JSON 卡片消息中的链接（如 QQ/OneBot 平台的分享卡片）
-- 🎨 完全自定义的解析结果格式，支持多项变量替换，变量无值自动隐藏行
-- 🐛 内置Debug调试模式，可详细记录所有操作与API交互日志
-- 📤 支持OneBot平台消息合并转发，优化多图文展示体验
-- 💬 所有提示文案均可自定义，适配多语言场景
-- 🔁 消息发送支持自动重试，与API重试配置联动，增强稳定性
-- 🚀 内置LRU内存缓存，避免短时间内重复解析同一链接；串行解析防止API限流
-- ⚡ 智能视频发送策略：优先直接发送URL，失败自动降级为本地文件发送
-- 🛡️ 可选视频大小限制，防止超大文件占满服务器磁盘；自动清理所有临时文件
+这是一个为 Koishi 机器人框架开发的**全平台视频/图集解析插件**，使用统一API接口，支持自动识别并解析抖音、快手、B站、小红书、微博、YouTube、TikTok、剪映、AcFun、知乎、虎牙等20+主流平台的短视频/图集/实况链接。
 
 ### English
-This is a **multi-platform video/image parsing plugin** developed for the Koishi bot framework, using a unified API interface to automatically recognize and parse short video/image/live photo links from 20+ mainstream platforms such as Douyin, Kuaishou, Bilibili, Xiaohongshu, Weibo, YouTube, TikTok, Jianying, AcFun, Zhihu, Huya and more. Core features:
-- 🌐 Unified API parsing, covering 20+ popular platforms without complex configuration
-- 🤖 Auto-detection of link sources, drop & go, and support for extracting links from XML/JSON card messages (e.g., share cards on QQ/OneBot)
-- 🎨 Fully customizable parsing result format with variable substitutions, empty variables hide the line automatically
-- 🐛 Built-in Debug mode, recording detailed operations and API interaction logs
-- 📤 Support OneBot message forwarding for better image/video display
-- 💬 All prompt texts are customizable for multilingual scenarios
-- 🔁 Message sending supports automatic retries, linked with API retry configuration for improved stability
-- 🚀 Built-in LRU memory cache to avoid repeated parsing of the same URL; serial parsing to prevent API rate limiting
-- ⚡ Smart video sending strategy: priority to send URL directly, auto downgrade to local file on failure
-- 🛡️ Optional video size limit to prevent oversized files from filling up server disk; automatic cleanup of all temporary files
+This is a **multi-platform video/image parsing plugin** developed for the Koishi bot framework, using a unified API interface to automatically recognize and parse short video/image/live photo links from 20+ mainstream platforms such as Douyin, Kuaishou, Bilibili, Xiaohongshu, Weibo, YouTube, TikTok, Jianying, AcFun, Zhihu, Huya and more. 
 
 ## 项目仓库 (Repository)
 - GitHub: `https://github.com/Minecraft-1314/koishi-plugin-video-parser-all`
@@ -71,6 +51,14 @@ This is a **multi-platform video/image parsing plugin** developed for the Koishi
 | `videoSendTimeout` | number | 60000 | 视频消息发送超时时间（毫秒，0 为不限制） |
 | `userAgent` | string | `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36` | API 请求使用的 User-Agent |
 
+### API 选择与回退设置
+| 配置项 | 类型 | 默认值 | 说明 |
+|--------|------|--------|------|
+| `primaryApiUrl` | string | `https://api.bugpk.com/api/short_videos` | 主 API 地址，解析时优先使用 |
+| `backupApiUrl` | string | `https://api.bugpk.com/api/svparse` | 备用主 API 地址，仅支持抖音、小红书、Instagram、即梦平台解析 |
+| `useDedicatedApiFirst` | boolean | false | 是否优先使用平台专属 API，失败后依次回退到主 API、备用主 API |
+| `customApis` | array | [] | 自定义平台专属 API 列表，每项需选择平台并填写 API 地址，可覆盖内置的默认专属 API |
+
 ### 错误与重试设置
 | 配置项 | 类型 | 默认值 | 说明 |
 |--------|------|--------|------|
@@ -81,7 +69,7 @@ This is a **multi-platform video/image parsing plugin** developed for the Koishi
 ### 发送方式设置
 | 配置项 | 类型 | 默认值 | 说明 |
 |--------|------|--------|------|
-| `enableForward` | boolean | false | 是否启用合并转发（仅 OneBot 平台），视频会单独发送 |
+| `enableForward` | boolean | false | 是否启用合并转发（仅 OneBot 平台），启用后视频与图文将整合进同一条合并消息 |
 
 ### 界面文字设置
 | 配置项 | 类型 | 默认值 | 说明 |