0

doc/ai_generation_model_config.md

@@ -0,0 +1,46 @@
+# AI 文章生成模型配置
+
+## 唯一更换位置
+
+文章生成接口实际使用的大模型 provider key 只从这里读取：
+
+`src/config/index.js` -> `commonConfig.aiGeneration.articleProvider`
+
+当前默认值：
+
+```js
+articleProvider: process.env.AI_GENERATION_PROVIDER || 'doubao-deepseek-v4-pro-260425'
+```
+
+以后更换文章生成大模型，只改这个配置项，或在服务器启动环境中设置。这个值可以是火山、阿里、腾讯、讯飞、OpenRouter、百度等任一已经在 `src/api/yjbdc/aiController.js` 的 `AIProviderFactory` 中支持的 provider key。
+
+```bash
+AI_GENERATION_PROVIDER=doubao-deepseek-v4-pro-260425
+```
+
+示例：
+
+```bash
+AI_GENERATION_PROVIDER=doubao-deepseek-v4-pro-260425
+AI_GENERATION_PROVIDER=ali-qwen-max
+AI_GENERATION_PROVIDER=tencent-hunyuan-turbos-latest
+AI_GENERATION_PROVIDER=xf-yun-spark-x1
+AI_GENERATION_PROVIDER=openrouter-moonshotai/kimi-k2
+```
+
+如果前端需要显示不同名称、版本号或预计生成时间，同一处配置同步调整：
+
+```js
+articleProviderVersion
+articleProviderContent
+articleProviderBuildSecond
+```
+
+## 当前策略
+
+- 后端忽略前端传入的 `AIVersion`，统一使用 `config.aiGeneration.articleProvider`。
+- `aiController.generateArticle(content, provider)` 的第二个参数只保留旧调用兼容，不再参与模型选择。
+- `/api/GetYJBDCGenerateConfig` 只返回当前配置的一个模型选项，避免前端显示已不可用的模型。
+- 不配置备用 provider，避免自动切到已不可用的模型或供应商。
+- 如果配置了不支持的 provider key，服务会显式报错，不会静默回退到某一家。
+- 使用火山 provider 时，VolcesAI 请求保留节流和 429 退避重试，减少 RPM 超限错误；使用其他 provider 时不受这组火山专用节流参数影响。

src/api/yjbdc/aiController.js

@@ -3,6 +3,98 @@ import crypto from 'crypto';
 import config from '../../config/index.js';
 import { enhanceFormsOfWords } from './enhanceFormsOfWords.js';
 
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+const toPositiveInteger = (value, fallback) => {
+    const number = Number(value);
+    return Number.isFinite(number) && number > 0 ? Math.floor(number) : fallback;
+};
+
+const VOLCES_MIN_INTERVAL_MS = toPositiveInteger(config.aiGeneration?.volcesMinIntervalMs, 15000);
+const VOLCES_MAX_RETRIES = toPositiveInteger(config.aiGeneration?.volcesMaxRetries, 2);
+const VOLCES_TIMEOUT_MS = toPositiveInteger(config.aiGeneration?.volcesTimeoutMs, 90000);
+
+let volcesNextRequestAt = 0;
+let volcesQueue = Promise.resolve();
+
+function getAxiosStatus(error) {
+    return error?.response?.status || error?.status;
+}
+
+function getExternalErrorCode(error) {
+    return error?.response?.data?.error?.code || error?.code || '';
+}
+
+function isRateLimitError(error) {
+    return getAxiosStatus(error) === 429 || String(getExternalErrorCode(error)).includes('RateLimit');
+}
+
+function isModelUnavailableError(error) {
+    return getAxiosStatus(error) === 404 || String(getExternalErrorCode(error)).includes('InvalidEndpointOrModel');
+}
+
+function sanitizeExternalError(error) {
+    return {
+        status: getAxiosStatus(error),
+        code: getExternalErrorCode(error),
+        message: error?.response?.data?.error?.message || error?.message
+    };
+}
+
+function createAIProviderError(provider, model, error) {
+    const status = getAxiosStatus(error);
+    const code = getExternalErrorCode(error);
+    const messageParts = [`${provider} API failed`];
+
+    if (status) {
+        messageParts.push(`status ${status}`);
+    }
+    if (code) {
+        messageParts.push(code);
+    }
+    if (error?.message) {
+        messageParts.push(error.message);
+    }
+
+    const providerError = new Error(messageParts.join(': '));
+    providerError.name = 'AIProviderError';
+    providerError.provider = provider;
+    providerError.model = model;
+    providerError.status = status;
+    providerError.code = code;
+    providerError.isExternalAIProviderError = true;
+    providerError.isRateLimit = isRateLimitError(error);
+    providerError.isModelUnavailable = isModelUnavailableError(error);
+    providerError.details = sanitizeExternalError(error);
+    providerError.cause = error;
+    return providerError;
+}
+
+async function waitForVolcesSlot() {
+    const previousQueue = volcesQueue;
+
+    let release;
+    volcesQueue = new Promise(resolve => {
+        release = resolve;
+    });
+
+    await previousQueue.catch(() => {});
+    try {
+        const waitMs = Math.max(0, volcesNextRequestAt - Date.now());
+        if (waitMs > 0) {
+            console.warn(`火山云AI请求节流，等待${Math.ceil(waitMs / 1000)}秒`);
+            await sleep(waitMs);
+        }
+        volcesNextRequestAt = Date.now() + VOLCES_MIN_INTERVAL_MS;
+    } finally {
+        release();
+    }
+}
+
+function delayVolcesRequests(delayMs) {
+    volcesNextRequestAt = Math.max(volcesNextRequestAt, Date.now() + delayMs);
+}
+
 /**
  * AI平台接口类
  * 定义了所有AI平台需要实现的方法
@@ -110,23 +202,35 @@ class VolcesAIProvider extends AIProvider {
             };
         }
 
-        try {
-            console.log(`火山云${this.version}`);
-            //console.log(JSON.stringify(postJSON));
-            // 移除encodeURI，直接使用原始URL
-            const response = await axios.post(this.url, postJSON, { headers: this.headers });
-            return response.data.choices[0].message.content;
-        } catch (error) {
-            console.error("VolcesAI API error:", error);
-            // 添加更详细的错误日志
-            if (error.response) {
-                console.error("错误详情:", {
-                    status: error.response.status,
-                    data: error.response.data
+        let lastError = null;
+
+        for (let attempt = 1; attempt <= VOLCES_MAX_RETRIES + 1; attempt++) {
+            try {
+                await waitForVolcesSlot();
+                console.log(`火山云${this.version}`);
+                //console.log(JSON.stringify(postJSON));
+                // 移除encodeURI，直接使用原始URL
+                const response = await axios.post(this.url, postJSON, {
+                    headers: this.headers,
+                    timeout: VOLCES_TIMEOUT_MS
                 });
+                return response.data.choices[0].message.content;
+            } catch (error) {
+                lastError = error;
+
+                if (isRateLimitError(error) && attempt <= VOLCES_MAX_RETRIES) {
+                    const backoffMs = Math.max(60000, VOLCES_MIN_INTERVAL_MS * (attempt + 1));
+                    delayVolcesRequests(backoffMs);
+                    console.warn(`火山云AI接口限流，第${attempt}次失败，等待${Math.ceil(backoffMs / 1000)}秒后重试`);
+                    await sleep(backoffMs);
+                    continue;
+                }
+
+                throw createAIProviderError('VolcesAI', this.model, error);
             }
-            throw error;
         }
+
+        throw createAIProviderError('VolcesAI', this.model, lastError);
     }
 }
 
@@ -538,25 +642,39 @@ class AIProviderFactory {
             case 'baidu-ernie-4.5-turbo-vl-32k-preview':
                 return new BaiduAIProvider("ernie-4.5-turbo-vl-32k-preview");
             default:
-                return new VolcesAIProvider("doubao-kimi-k2-250711"); // 默认使用火山云1.5
+                throw new Error(`Unsupported AI provider: ${provider}`);
         }
     }
 }
 
+AIProviderFactory.getProvider(config.aiGeneration?.articleProvider || 'doubao-deepseek-v4-pro-260425');
+
 /**
  * 生成文章的主函数
  * @param {string} content - 生成文章的提示内容
- * @param {string} provider - AI提供者名称，默认为'volces'
+ * @param {string} provider - 保留兼容旧调用，实际提供者统一读取 config.aiGeneration.articleProvider
  * @returns {Promise<string>} - 返回生成的文章JSON字符串
  */
 async function generateArticle(content, provider) {
+    const currentProvider = config.aiGeneration?.articleProvider || 'doubao-deepseek-v4-pro-260425';
+
     try {
-        const aiProvider = AIProviderFactory.getProvider(provider);
+        const aiProvider = AIProviderFactory.getProvider(currentProvider);
         //console.log(JSON.stringify(aiProvider));
         const result = await aiProvider.generateArticle(content);
         return result;
     } catch (error) {
-        console.error("Generate article error:", error);
+        if (error?.isExternalAIProviderError) {
+            console.error("Generate article error:", {
+                provider: error.provider,
+                model: error.model,
+                status: error.status,
+                code: error.code,
+                message: error.message
+            });
+        } else {
+            console.error("Generate article error:", error);
+        }
         throw error;
     }
 }
@@ -710,4 +828,4 @@ export default {
     enhanceFormsOfWords,
     validateAndFixJSON,
     normalizeArticleFields
-};
+};

src/api/yjbdc/yjbdcController.js

@@ -86,35 +86,14 @@ export async function GenerateArticle(ctx) {
             };
             content = JSON.stringify(content);
 
-            // 从请求参数中获取AI提供者，如果没有指定则使用默认值
-            let aiProvider = '';
-            for (let i = 0; i < menuConfig.AIVersion.length; i++) {
-                if (menuConfig.AIVersion[i].Version == params.AIVersion) {
-                    aiProvider = menuConfig.AIVersion[i].Model;
-                    break;
-                }
-            }
-
-            //给用户一些比较好的体验
-            
-            // 按照权重概率分配AI提供商：40%概率使用ali-Moonshot-Kimi-K2-Instruct，60%概率使用doubao-kimi-k2-250711
-            aiProvider = stringUtils.weightedRandom({
-                // 'ali-Moonshot-Kimi-K2-Instruct': 40,
-                // 'ali-Moonshot-Kimi-K2-Instruct': 60,
-                //'doubao-deepseek-v3-250324': 100,
-                //'doubao-kimi-k2-250711': 100,
-                //'doubao-deepseek-v3-2-251201': 100,
-                //'doubao-seed-1-8-251228': 100,
-                'doubao-deepseek-v4-pro-260425':100,
-                //'ali-Moonshot-kimi-k2.5': 100,
-            });
+            const aiProvider = config.aiGeneration.articleProvider;
            
 
             try {
                 //开始时间
                 let timeStart = new Date().getTime();
                 // 使用aiController生成文章
-                let result2 = await aiController.generateArticle(content, aiProvider);
+                let result2 = await aiController.generateArticle(content);
 
                 //console.log(result2);
                 //debugger;
@@ -391,17 +370,14 @@ export async function GetYJBDCGenerateConfig(ctx) {
     }
 
 
-    if (param.UserID > 3) {
-        result.AIVersion.splice(2, result.AIVersion.length - 2);
-        if (param.UserID == 185) {
-            const configArr = constantClass.GetYJBDCGenerateConfig();
-            result.AIVersion.push(configArr.AIVersion[5]);
-        }
-        // if (param.UserID<4){
-        //     const configArr=constantClass.GetYJBDCGenerateConfig();
-        //     result.AIVersion.push(configArr.AIVersion[6]);
-        // }
-    }
+    result.AIVersion = [{
+        Version: config.aiGeneration.articleProviderVersion,
+        BuildSecond: config.aiGeneration.articleProviderBuildSecond,
+        Model: config.aiGeneration.articleProvider,
+        Content: config.aiGeneration.articleProviderContent,
+        CSS: "Selected"
+    }];
+
     ctx.body = { "errcode": 10000, result: result };
 }
 
@@ -1341,16 +1317,28 @@ export async function GetWordDetail(ctx) {
         return;
     }
 
+    const fetchWordDetail = async (word) => {
+        try {
+            const url = "https://www.kylx365.com/api/GetMiaoguoAISearch2?Word=" + encodeURIComponent(word);
+            const response = await axios.get(url, { timeout: 10000 });
+            return response.data?.result || [];
+        } catch (error) {
+            console.warn("GetWordDetail external lookup failed:", {
+                word,
+                status: error?.response?.status,
+                message: error?.message
+            });
+            return [];
+        }
+    };
+
     // 使用单词作为缓存键，为每个单词单独缓存结果
     const cacheKey = `GetWordDetail_${param.Word}`;
     let result = globalCache.get(cacheKey);
 
     if (!result) {
         // 缓存未命中，从数据库获取
-        let url = "https://www.kylx365.com/api/GetMiaoguoAISearch2?Word=";
-        const tokenurl=url + param.Word;
-        result = await axios.get(tokenurl);
-        result=result.data.result;
+        result = await fetchWordDetail(param.Word);
 
         // 如果没有找到结果，尝试查找单词的原形
         if (!result || result.length === 0) {
@@ -1360,11 +1348,7 @@ export async function GetWordDetail(ctx) {
             // 尝试每个可能的原形
             for (const baseWord of possibleBaseWords) {
                 //console.log(`尝试查找单词 ${param.Word} 的可能原形: ${baseWord}`);
-                const baseParam = { ...param, Word: baseWord };
-                
-                const tokenurl=url + baseParam;
-                let baseResult = await axios.get(tokenurl);
-                baseResult=baseResult.data.result;
+                const baseResult = await fetchWordDetail(baseWord);
 
                 if (baseResult && baseResult.length > 0) {
                     //console.log(`找到单词 ${param.Word} 的原形 ${baseWord}`);

src/config/index.js

@@ -23,6 +23,15 @@ const commonConfig = {
         maxPayloadLength: toNumber(process.env.ERROR_LOG_MAX_PAYLOAD_LENGTH, 8000),
         maxStackLength: toNumber(process.env.ERROR_LOG_MAX_STACK_LENGTH, 30000)
     },
+    aiGeneration: {
+        articleProvider: process.env.AI_GENERATION_PROVIDER || 'doubao-deepseek-v4-pro-260425',
+        articleProviderVersion: process.env.AI_GENERATION_PROVIDER_VERSION || 'zdp4f',
+        articleProviderContent: process.env.AI_GENERATION_PROVIDER_CONTENT || '字节deepseek_v4pro\n平均30秒生成',
+        articleProviderBuildSecond: toNumber(process.env.AI_GENERATION_PROVIDER_BUILD_SECOND, 30),
+        volcesMinIntervalMs: toNumber(process.env.VOLCES_AI_MIN_INTERVAL_MS, 15000),
+        volcesMaxRetries: toNumber(process.env.VOLCES_AI_MAX_RETRIES, 2),
+        volcesTimeoutMs: toNumber(process.env.VOLCES_AI_TIMEOUT_MS, 90000)
+    },
     CDNUrl: 'https://cdn.example.com/',
     database: {
         multipleStatements: true,