@tencentcloud/sdk-mcp 1.6.4 → 1.6.6

package/knowledge/search/search-knowledge.js

@@ -23,7 +23,7 @@ function loadManifest() {
     cachedManifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
     return cachedManifest;
 }
-function postProcess(ranked, chunksById, limit) {
+function postProcess(ranked, chunksById, limit, opts) {
     const sourceCount = {};
     const urlMappingSourceCount = {};
     /** 已入选的 push config/android/{vendor} 文件，用于抑制其他厂商噪声 */
@@ -34,9 +34,10 @@ function postProcess(ranked, chunksById, limit) {
         if (!chunk)
             continue;
         const isUrlMapping = Boolean(isUrlMappingSource(chunk.source));
+        const isPinnedUrlRow = isUrlMapping && (opts?.pinnedUrlRowChunkIds?.has(chunk.id) ?? false);
         if (isUrlMapping) {
             const urlCount = urlMappingSourceCount[chunk.source] ?? 0;
-            if (urlCount >= 1)
+            if (!isPinnedUrlRow && urlCount >= 1)
                 continue;
             urlMappingSourceCount[chunk.source] = urlCount + 1;
         }
@@ -68,22 +69,33 @@ function postProcess(ranked, chunksById, limit) {
         if (firstPush) {
             // 首条不设分数截止，至少保证 1 条返回
         }
-        else {
+        else if (!isPinnedUrlRow) {
             // 分数衰减到 top 的 5% 以下时停止，不硬填到 limit
+            // chat/urls 的行级精确命中（E7）不受该规则截断，保证多子主题可并行返回
             const topScore = fragments[0].score;
             if (topScore > 0 && item.score < topScore * 0.05)
                 break;
         }
+        const contentWithHint = chunk.contains_code
+            ? `【代码示例，须与目标端一致】\n${chunk.content}`
+            : chunk.content;
         fragments.push({
             rank: fragments.length + 1,
             score: item.score,
             title: chunk.title,
-            content: chunk.content,
+            content: contentWithHint,
             source: chunk.source,
             doc_urls: resolveFragmentDocUrls(chunk.source, chunk.content, getSourceFileContent(chunk.source)),
             product: chunk.product,
             framework: chunk.framework,
             types: chunk.types,
+            variant: chunk.variant,
+            scope: chunk.scope,
+            doc_kind: chunk.doc_kind,
+            capability_status: chunk.capability_status,
+            api_names: chunk.api_names,
+            contains_code: chunk.contains_code,
+            citation: `[来源: ${chunk.id}]`,
             chunk_id: chunk.id,
         });
         if (fragments.length >= limit)
@@ -112,60 +124,166 @@ function partitionFragments(fragments) {
     const urlMappingKinds = [...new Set(urlMapping.map((f) => isUrlMappingSource(f.source)).filter(Boolean))];
     return { urlMapping, localDoc, urlMappingKinds };
 }
+function hasBestPracticeFragment(fragments) {
+    return fragments.some((f) => /\/best-practice\//i.test(f.source));
+}
+function inferQueryApiTokens(prompt) {
+    const tokens = new Set();
+    const upperNoise = new Set(['SDK', 'API', 'HTTP', 'HTTPS', 'JSON', 'CALL', 'NAME', 'STATUS']);
+    for (const match of prompt.matchAll(/\b([a-z]+[A-Z][A-Za-z0-9_]*)\b/g)) {
+        tokens.add(match[1]);
+    }
+    for (const match of prompt.matchAll(/\b([A-Z][A-Za-z0-9_]*\.[A-Za-z_][A-Za-z0-9_]*)\b/g)) {
+        tokens.add(match[1]);
+    }
+    for (const match of prompt.matchAll(/\b(use[A-Z]\w*)\b/g)) {
+        tokens.add(match[1]);
+    }
+    for (const match of prompt.matchAll(/\b(I[A-Z][A-Za-z0-9_]*)\b/g)) {
+        tokens.add(match[1]);
+    }
+    for (const match of prompt.matchAll(/\b([A-Z][A-Za-z0-9_]*\.[A-Z_][A-Z0-9_]*)\b/g)) {
+        tokens.add(match[1]);
+    }
+    for (const match of prompt.matchAll(/\b([A-Z_]{3,})\b/g)) {
+        const token = match[1];
+        if (!upperNoise.has(token))
+            tokens.add(token);
+    }
+    return [...tokens];
+}
+function tokenInChunk(token, chunk) {
+    if (chunk.api_names?.some((name) => name.toLowerCase() === token.toLowerCase()))
+        return true;
+    if (chunk.symbols?.some((name) => name.toLowerCase() === token.toLowerCase()))
+        return true;
+    const low = token.toLowerCase();
+    return chunk.title.toLowerCase().includes(low) || chunk.source.toLowerCase().includes(low);
+}
+function computeApiNameCoverage(tokens, candidates) {
+    if (!tokens.length)
+        return 1;
+    const hit = tokens.filter((token) => candidates.some((chunk) => tokenInChunk(token, chunk))).length;
+    return Number((hit / tokens.length).toFixed(2));
+}
+function computeMissingApiTokens(tokens, candidates) {
+    if (!tokens.length)
+        return [];
+    return tokens.filter((token) => !candidates.some((chunk) => tokenInChunk(token, chunk)));
+}
+function applyRankMultipliers(ranked, chunksById, opts) {
+    const adjusted = ranked.map((item) => {
+        const chunk = chunksById.get(item.id);
+        if (!chunk)
+            return item;
+        let multiplier = 1;
+        // A2: 传了 product 时，命中 scope 的通配语料允许召回但降权
+        if (opts.product?.length && chunk.product === '*') {
+            multiplier *= 0.2;
+        }
+        // F2: framework 软降权（保留硬过滤，处理 fallback/边界残留）
+        if (opts.framework && opts.frameworks?.length && !chunk.framework.includes('*')) {
+            const explicitMatch = opts.frameworks.some((fw) => chunk.framework.includes(fw));
+            const callCoreWebFallback = Boolean(opts.product?.includes('call')
+                && (opts.framework === 'react' || opts.framework === 'vue')
+                && chunk.variant === 'core-sdk'
+                && chunk.framework.includes('web'));
+            const liveWebVueFallback = Boolean(opts.product?.includes('live')
+                && opts.framework === 'web'
+                && chunk.variant === 'core-sdk'
+                && chunk.framework.includes('vue')
+                && chunk.source.includes('/api-reference/'));
+            if (!explicitMatch && !callCoreWebFallback && !liveWebVueFallback) {
+                multiplier *= 0.2;
+            }
+        }
+        return { ...item, score: item.score * multiplier };
+    });
+    return adjusted.sort((a, b) => b.score - a.score);
+}
 /**
- * P0-3：相对阈值的置信度评估。
- * - high：top ≥ 50 或有精确命中（exactHits 非空）
- * - medium：top ≥ 10 且 top / second ≥ 1.3（区分度足够）
- * - low：top 较低或与 second 接近（同水位竞争，agent 应谨慎）
- * - none：fragments 为空
+ * 多因子置信度评估：exact 命中 + 分数梯度 + API 覆盖度。
  */
-function assessConfidence(fragments, exactHits) {
+function assessConfidence(fragments, exactHits, apiNameCoverage, queryApiTokens) {
     if (fragments.length === 0) {
         return { confidence: 'none', status: 'empty' };
     }
     const top = fragments[0].score;
     const second = fragments[1]?.score ?? 0;
-    if (exactHits.length > 0 || top >= 50) {
-        return { confidence: 'high', status: 'success' };
-    }
     const ratio = second > 0 ? top / second : Infinity;
-    if (top >= 10 && ratio >= 1.3) {
-        return { confidence: 'medium', status: 'success' };
-    }
-    if (top >= 5 && ratio >= 1.15) {
-        return { confidence: 'medium', status: 'success' };
+    let confidence;
+    if (exactHits.length > 0 || top >= 50)
+        confidence = 'high';
+    else if (top >= 12 && ratio >= 1.25)
+        confidence = 'medium';
+    else if (top >= 6 && ratio >= 1.12)
+        confidence = 'medium';
+    else
+        confidence = 'low';
+    // D2: API 覆盖过低时，confidence 上限降为 low
+    if (queryApiTokens.length > 0 && apiNameCoverage < 0.3) {
+        confidence = 'low';
     }
-    return { confidence: 'low', status: 'low_confidence' };
+    const status = confidence === 'low' ? 'low_confidence' : 'success';
+    return { confidence, status };
+}
+function buildAnswerContract(status, confidence, opts) {
+    const uncertaintyRule = status === 'low_confidence' || confidence === 'low'
+        ? '当信息不足时必须显式写“待确认：”，只允许陈述缺口，不允许猜测补全。'
+        : '除“待确认：”段落外，不得出现“可能/大概/应该/推测”等猜测措辞。';
+    const riskRule = opts?.fabricationRisk
+        ? 'fabrication_risk=true 时，若片段未覆盖该细节，必须输出“待确认：知识片段未覆盖此项”。'
+        : '';
+    return [
+        '【输出模板（必须遵守）】',
+        '使用“问题导向”标题组织答案，优先复用用户提问原句：一、<问题1> 二、<问题2> 三、<问题3> …',
+        '每个小节先给直接结论，再补 1-2 句必要说明；避免模板化术语（如“依据/操作”字样）。',
+        '信息缺口统一放在对应小节末尾，使用“待确认：xxx”；若全都确认则可省略“待确认”小节。',
+        '末尾保留“参考文档”小节，仅列文档标题或 URL；正文不展示检索过程、证据链、打分细节。',
+        '用户可见正文禁止出现系统检索话术（如“命中片段/检索结果/置信度/分数/召回/重排”）。',
+        '硬约束：不得引入 fragments 未出现的 API 名、字段值、枚举项、事件名。',
+        uncertaintyRule,
+        riskRule,
+    ].filter(Boolean).join(' ');
 }
-function buildAgentMessage(status, fragments, confidence, references) {
-    const citeTail = references?.length
-        ? '作答时 MUST 在答案末尾附「**参考文档**」小节，逐条列出 `meta.references`（或各 fragment 的 `doc_urls`）中的 URL，便于用户核对；禁止编造未出现的链接。'
-        : '若 fragments 含 `doc_urls`，作答时须在末尾附「**参考文档**」列出对应 URL；禁止编造链接。';
-    const tail = `${citeTail} Final answer drafted -> MUST call \`finalize_answer\` before replying. Explicit follow-up feedback -> call \`submit_feedback\`.`;
+function buildAgentMessage(status, fragments, confidence, _references, opts) {
+    const platformRule = '端别硬规则：字段/API 描述前先标注【端别: framework】；禁止“部分版本也称 xxx”这类跨端混写；字段大小写必须与目标端文档一致；多端片段同时命中时主答案仅讲目标端，其他端差异放末尾简述；无片段覆盖的细节禁止补全。';
+    const riskRule = opts?.fabricationRisk ? '当前检索存在幻觉风险（fabrication_risk=true）：禁止补全未命中 API 细节。' : '';
+    const answerContract = buildAnswerContract(status, confidence, opts);
+    const tail = `${platformRule} ${riskRule} ${answerContract} Final answer drafted -> MUST call \`finalize_answer\` before replying. Explicit follow-up feedback -> call \`submit_feedback\`.`;
     if (status === 'needs_framework') {
-        return '【硬规则】问题依赖具体平台实现，但未指定 framework，全平台混检信息密度低且被禁止。MUST 先调用 `present_framework_choice`（传入 product），等用户选定 android/ios/flutter/react/vue/uni-app 等后再调用本工具，并 MUST 带上 **product + framework**。禁止传空 framework 硬搜。';
+        return '【硬规则】问题依赖具体平台实现，但未指定 frameworks，全平台混检信息密度低且被禁止。MUST 先调用 `present_framework_choice`（传入 product），等用户选定 web/miniprogram/android/ios/flutter/react/vue/uni-app 等后再调用本工具，并 MUST 带上 **product + frameworks**。禁止传空 frameworks 硬搜。';
     }
     const { urlMapping, localDoc, urlMappingKinds } = partitionFragments(fragments);
     const hasUrlMapping = urlMapping.length > 0;
     const hasLocalDoc = localDoc.length > 0;
+    const hasBestPractice = hasBestPracticeFragment(fragments);
     const urlKindLabel = urlMappingKinds.join(' / ') || 'urls';
     if (status === 'success' && fragments.length > 0) {
-        const confidenceHint = confidence === 'high' ? '(confidence=high)'
-            : confidence === 'medium' ? '(confidence=medium，top 与次优区分度一般，作答时如有不确定可向用户确认)'
-                : '';
+        const topFragment = fragments[0];
+        if (topFragment?.capability_status === 'unsupported') {
+            const scopeLabel = topFragment.scope ? `（${topFragment.scope}）` : '';
+            return `当前问题在该平台 / 形态下 **不支持**${scopeLabel}。回答 MUST：① 第一段先明确写“**不支持**”；② 说明这是当前平台 Core 的能力边界，而不是缺少示例代码；③ 仅提供当前平台已支持的替代方案（如对应平台 preset 预制 UI）；若当前知识库未给出明确替代形态，应直接说明暂无可执行替代路径；④ **禁止**输出当前平台 Core 的 API 调用步骤或集成步骤。${tail}`;
+        }
         if (hasUrlMapping && !hasLocalDoc) {
-            return `知识库命中 **L1 URL 映射**${confidenceHint}（${urlKindLabel}，共 ${urlMapping.length} 条片段）。这些 fragments **仅为官网文档入口**（cloud.tencent.com / web.sdk.qcloud.com 等），**不含** REST API、错误码、Webhook 全文。MUST：① 在 fragments 中匹配用户问题对应的**目标 URL**；② **自行抓取**该 URL 的官网文档后再合成答案；③ 禁止仅复述映射表或臆造 API/错误码细节。${tail}`;
+            return `当前可用信息主要是文档入口链接（${urlKindLabel}）。请先匹配用户问题对应的目标 URL，抓取官网文档后再合成答案；禁止仅复述映射表或臆造 API/错误码细节。${tail}`;
         }
         if (hasUrlMapping && hasLocalDoc) {
-            return `知识库返回 ${fragments.length} 条片段${confidenceHint}：${localDoc.length} 条本地文档 + ${urlMapping.length} 条 URL 映射（${urlKindLabel}）。**本地文档片段**（preset/integration 等）可直接基于 content 作答；**URL 映射片段** MUST 提取其中目标 URL 并**自行抓取**官网文档后再作答，禁止仅复述映射表。${tail}`;
+            if (hasBestPractice) {
+                return `优先基于已命中的 best-practice 与本地片段直接作答；URL 映射仅作补充参考，不要再抓官网做二次求证。${tail}`;
+            }
+            return `本地文档片段可直接用于作答；若本地片段未覆盖关键细节，再从 URL 映射中提取目标 URL 抓取官网文档补齐。${tail}`;
         }
-        return `知识库已返回 ${fragments.length} 条有效片段${confidenceHint}。请**仅基于 fragments** 合成答案；**不要**并行 web_search 或再去官网抓文档。${tail}`;
+        return `请仅基于已返回 fragments 合成答案；不要并行 web_search 或额外抓取官网文档。${tail}`;
     }
     if (status === 'low_confidence') {
         if (hasUrlMapping) {
-            return `知识库置信度偏低（confidence=low：top 分数低或与次优过于接近），但命中 URL 映射（${urlKindLabel}）。请从 fragments 提取目标 URL 并**自行抓取**官网文档后作答；若映射表未覆盖用户问题，向用户说明不确定之处。${tail}`;
+            if (hasBestPractice) {
+                return `优先基于 best-practice 与本地片段给出可执行结论；未覆盖的内容统一写入“待确认”，不要默认抓官网二次求证。${tail}`;
+            }
+            return `请先从 URL 映射里提取目标 URL 并抓取官网文档补齐关键信息，再给出答案；仍无法确认的内容明确写“待确认”。${tail}`;
         }
-        return `知识库置信度偏低（confidence=low：top 分数低或与次优过于接近，可能未精确命中用户问题）。请基于已有 fragments 尽力作答，并**主动向用户说明不确定之处**；可考虑让用户补充更具体的描述（如组件名 / API 名 / 错误码）后重新检索。**不要**默认并行 web_search。${tail}`;
+        return `请基于已有 fragments 给出最可执行答案，并将未覆盖细节明确写为“待确认”；可引导用户补充组件名/API 名/错误码后重新检索。不要默认并行 web_search。${tail}`;
     }
     return `知识库未命中有效片段。请向用户说明并确认 product/framework 是否准确；若仍无 platform 信息且问题依赖具体客户端，应先 \`present_framework_choice\`。${tail}`;
 }
@@ -188,42 +306,110 @@ export function searchKnowledge(params) {
     }
     const manifest = loadManifest();
     const allChunks = manifest.chunks;
-    let pool = filterPool(allChunks, norm);
-    // 自愈：types 过滤导致 0 命中时，丢掉 types 再过滤一次，避免误传类型标签直接返回 empty
-    if (pool.length === 0 && norm.types?.length) {
-        pool = filterPool(allChunks, { ...norm, types: undefined });
-    }
-    const { boosts, exactHits } = runExactLookup(norm.prompt, pool, norm);
-    // P0-4：用 product 级缓存的 BM25 索引对子集打分（首次构建，后续命中缓存）
-    // 索引基于该 product 全量 chunks（含 integration corpus）；
-    // 子集 ranking 只对 filteredPool.map(id) 打分，IDF 用更稳的产品级全量统计。
-    // 支持多 product 同时检索（products 数组），跨域问题如 Chat + Push 能同时命中各方知识。
-    const productIndex = getProductsBM25Index(allChunks, norm.product);
-    const poolWithContent = attachPoolContent(pool);
-    const chunksById = new Map(poolWithContent.map((chunk) => [chunk.id, chunk]));
-    const ranked = rankSubsetWithIndex(norm.prompt, pool.map((chunk) => chunk.id), productIndex, boosts);
-    const fragments = postProcess(ranked, chunksById, norm.limit);
-    const urlMappingSources = [...new Set(fragments.map((f) => f.source).filter((source) => isUrlMappingSource(source)))];
-    const references = buildReferences(fragments);
-    // P0-3：相对阈值评估置信度（替代原硬编码 0.5 死阈值）
-    const { confidence, status } = assessConfidence(fragments, exactHits);
-    const topScore = fragments[0]?.score;
-    const secondScore = fragments[1]?.score;
+    const queryApiTokens = inferQueryApiTokens(norm.prompt);
+    const runSearchPass = (passNorm, opts) => {
+        let pool = filterPool(allChunks, passNorm);
+        // types 误传自愈：首轮保留，二次扩检也同样保留该能力
+        if (pool.length === 0 && passNorm.types?.length) {
+            pool = filterPool(allChunks, { ...passNorm, types: undefined });
+        }
+        const { boosts, exactHits, urlRowHitChunkIds } = runExactLookup(passNorm.prompt, pool, passNorm);
+        // A2 补充正向路由：UserSig 问法下允许 share 命中且优先于无关 urls 噪声
+        if (/usersig|sdkappid|secretkey|鉴权|签名|gentestusersig/i.test(passNorm.prompt)) {
+            for (const chunk of pool) {
+                if (chunk.product === '*' && chunk.source.includes('knowledge/share/userSig.md')) {
+                    boosts[chunk.id] = (boosts[chunk.id] ?? 0) + 220;
+                }
+            }
+        }
+        // B2: API 覆盖不足扩检时，对 api/integration 语料做轻量重排提权
+        if (opts?.apiRetry) {
+            for (const chunk of pool) {
+                if (chunk.types.includes('api') || chunk.types.includes('integration')) {
+                    boosts[chunk.id] = (boosts[chunk.id] ?? 0) + 40;
+                }
+            }
+        }
+        const productIndex = getProductsBM25Index(allChunks, passNorm.product);
+        const poolWithContent = attachPoolContent(pool);
+        const chunksById = new Map(poolWithContent.map((chunk) => [chunk.id, chunk]));
+        const ranked = rankSubsetWithIndex(passNorm.prompt, pool.map((chunk) => chunk.id), productIndex, boosts);
+        const rankedWithMultipliers = applyRankMultipliers(ranked, chunksById, {
+            product: passNorm.product,
+            framework: passNorm.framework,
+            frameworks: passNorm.frameworks,
+        });
+        const pinnedUrlRowChunkIds = new Set(urlRowHitChunkIds);
+        const fragments = postProcess(rankedWithMultipliers, chunksById, passNorm.limit, {
+            pinnedUrlRowChunkIds,
+        });
+        const urlMappingSources = [...new Set(fragments.map((f) => f.source).filter((source) => isUrlMappingSource(source)))];
+        const references = buildReferences(fragments);
+        const apiNameCoverage = computeApiNameCoverage(queryApiTokens, poolWithContent);
+        const missingApiTokens = computeMissingApiTokens(queryApiTokens, poolWithContent);
+        return {
+            pool,
+            fragments,
+            exactHits,
+            urlMappingSources,
+            references,
+            apiNameCoverage,
+            missingApiTokens,
+            urlMapRelaxed: pinnedUrlRowChunkIds.size > 0,
+            urlMapExactHitCount: pinnedUrlRowChunkIds.size,
+        };
+    };
+    let pass = runSearchPass(norm);
+    let retryReason;
+    // B2: API token 覆盖不足时触发一次扩检（去掉 types 约束 + api/integration 轻提权）
+    const missingRatio = queryApiTokens.length > 0
+        ? Number((pass.missingApiTokens.length / queryApiTokens.length).toFixed(2))
+        : 0;
+    if (queryApiTokens.length > 0 && (pass.apiNameCoverage === 0 || missingRatio >= 0.3)) {
+        const retryPass = runSearchPass({ ...norm, types: undefined }, { apiRetry: true });
+        const retryMissingRatio = queryApiTokens.length > 0
+            ? Number((retryPass.missingApiTokens.length / queryApiTokens.length).toFixed(2))
+            : 0;
+        if (retryPass.apiNameCoverage > pass.apiNameCoverage
+            || retryMissingRatio < missingRatio
+            || (pass.fragments.length === 0 && retryPass.fragments.length > 0)) {
+            pass = retryPass;
+            retryReason = `api_gap_retry:coverage=${pass.apiNameCoverage},missing_ratio=${retryMissingRatio}`;
+        }
+    }
+    const routeInconsistencyWarning = pass.fragments.length > 0
+        ? pass.fragments.filter((f) => f.product === '*').length / pass.fragments.length > 0.3
+        : false;
+    const { confidence, status } = assessConfidence(pass.fragments, pass.exactHits, pass.apiNameCoverage, queryApiTokens);
+    const fabricationRisk = (queryApiTokens.length > 0 && pass.apiNameCoverage < 0.3)
+        || (confidence === 'low' && pass.fragments.length < 2);
+    const topScore = pass.fragments[0]?.score;
+    const secondScore = pass.fragments[1]?.score;
+    const answerContract = buildAnswerContract(status, confidence, { fabricationRisk });
     return {
         status,
         confidence,
-        message: buildAgentMessage(status, fragments, confidence, references),
+        message: buildAgentMessage(status, pass.fragments, confidence, pass.references, { fabricationRisk }),
         query: params,
         meta: {
             pool_size: allChunks.length,
-            filtered_size: pool.length,
-            exact_hits: exactHits,
-            ...(urlMappingSources.length ? { url_mapping_sources: urlMappingSources } : {}),
-            ...(references.length ? { references } : {}),
+            filtered_size: pass.pool.length,
+            exact_hits: pass.exactHits,
+            ...(pass.urlMappingSources.length ? { url_mapping_sources: pass.urlMappingSources } : {}),
+            ...(pass.urlMapRelaxed ? { url_map_relaxed: pass.urlMapRelaxed } : {}),
+            ...(pass.urlMapExactHitCount > 0 ? { url_map_exact_hit_count: pass.urlMapExactHitCount } : {}),
+            ...(pass.references.length ? { references: pass.references } : {}),
             ...(topScore !== undefined ? { top_score: Number(topScore.toFixed(2)) } : {}),
             ...(secondScore !== undefined ? { second_score: Number(secondScore.toFixed(2)) } : {}),
+            ...(queryApiTokens.length ? { query_api_tokens: queryApiTokens } : {}),
+            ...(pass.missingApiTokens.length ? { missing_api_tokens: pass.missingApiTokens } : {}),
+            ...(retryReason ? { retry_reason: retryReason } : {}),
+            answer_contract: answerContract,
+            api_name_coverage: pass.apiNameCoverage,
+            fabrication_risk: fabricationRisk,
+            route_inconsistency_warning: routeInconsistencyWarning,
         },
-        fragments,
+        fragments: pass.fragments,
     };
 }
 export { normalizeParams, filterPool };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tencentcloud/sdk-mcp",
-  "version": "1.6.4",
+  "version": "1.6.6",
   "description": "Tencent Cloud MCP Server for SDK",
   "type": "module",
   "main": "index.js",

package/resource/_schema/feature-aliases.yaml

@@ -4,6 +4,7 @@ live:
   live-co-guest-interaction.md: ["连麦", "观众连麦", "co_guest", "CoGuest"]
   live-host-interaction.md: ["PK", "主播连线", "co_host"]
   live-base-beauty.md: ["美颜", "base_beauty"]
+  live-list.md: ["直播列表", "房间列表", "live_list", "房间大厅"]
   voice-co-guest-interaction.md: ["语聊房上麦", "上麦", "voice co guest", "co guest"]
 room:
   screen-share.md: ["屏幕分享", "screen share", "startScreenShare"]

package/resource/integration/callkit/preset/android/integration.md

@@ -52,7 +52,6 @@ dependencies {
 
    > **说明：**
    >
-
    > TUICallKit 工程内部已经默认依赖：`TRTC SDK`、`IM SDK`、`tuicallengine` 以及公共库 `tuicore`，不需要开发者单独配置。如需进行版本升级，则修改`tuicallkit-kt/build.gradle`文件中的版本号即可。
    >
 
@@ -77,12 +76,12 @@ dependencies {
 
    > **说明：**
    >
-
    > 如果您集成 tuicallkit-kt 后报如下错误：
    >
-
+   >
    > 原因是 AGP 8.0+ 要求 Gradle 运行时使用 Java 17 或更高版本。您可以在 Android Studio 中点击 Tools -> SDK Manager -> Build,Execution,Deployment -> Build Tools -> Gradle 配置 Gradle JDK 版本为 17 解决该问题
    >
+   >
 
 ### 步骤3：登录
 
@@ -421,7 +420,7 @@ TUICallKit.createInstance(this).join(callId, new CompletionHandler() {
 ### 设置语言
 - **支持的语言：**目前支持**简体中文、繁体中文、英文、日文和阿拉伯语。**
 
-- **切换语言：**TUICallKit 默认语言与手机系统保持一致 。如果需要切换语言，可以使用 `TUIThemeManager.getInstance().changeLanguage `方法设置语言，以设置语言为英文的示例代码如下**。**
+- **切换语言：**TUICallKit 默认语言与手机系统保持一致 。如果需要切换语言，可以使用 `TUIThemeManager.getInstance().changeLanguage` 方法设置语言，以设置语言为英文的示例代码如下**。**
 
 【Kotlin】
 ``` java
@@ -459,7 +458,6 @@ public class MainActivity extends BaseActivity {
 
 > **说明：**
 >
-
 >
 
 ### 设置铃声

package/resource/integration/callkit/preset/flutter/integration.md

@@ -87,12 +87,12 @@ android {
 
 > **注意：**
 >
-
 > 由于 tencent_rtc_sdk 通过 Flutter FFI 调用接口，iOS Release 构建时 Xcode 的符号裁剪优化可能误移除 TRTC 的 C 符号，引发 `symbol not found` 错误。解决方案如下：
 >
 > 1. 在项目的 Build Settings 中找到 **Deployment Postprocessing**，将其设置为 **Yes 。**
-
+>
 > 2. 在项目的 Build Settings 中找到 **Strip Style**，将其中 Release 的值设置为 **Non-Global Symbols 。**
+>
 
 - Flutter 工程配置
 
@@ -301,7 +301,6 @@ void join() {
 
    > **说明：**
    >
-
    >
 
 ### 铃声设置

package/resource/integration/callkit/preset/ios/integration.md

@@ -64,7 +64,6 @@ pod init
 
    > **提示：**
    >
-
    > 安装完成后，使用 `YourProjectName.xcworkspace` 文件打开项目
    >
 
@@ -177,7 +176,6 @@ TUICallKit.createInstance().setSelfInfo(nickname: "jack", avatar: "https:/****/u
 
 > **注意：**
 >
-
 > calls 接口不能写在 viewDidLoad 方法中，应放在按钮的点击事件或其他用户交互的响应方法中调用。
 >
 
@@ -330,7 +328,6 @@ func setLanguage() {
 
 > **说明：**
 >
-
 >
 
 ### 铃声设置
@@ -402,9 +399,9 @@ TUICallKit.createInstance().enableMuteMode(enable: true)
 
 **支持**，如需要进入后台仍然运行相关功能，可选中当前工程项目，在 **Capabilities** 下的 **Background Modes** 模块中勾选 **Audio，AirPlay, and Picture in Picture** ，如下图所示：
 
-### Xcode 出现 **Sandbox: rsync **编译报错？
+### Xcode 出现 **Sandbox: rsync** 编译报错？
 
-可以在 **Build Settings **中把 **User Script Sandboxing **设置为 **NO：**
+可以在 **Build Settings** 中把 **User Script Sandboxing** 设置为 **NO：**
 
 如果您在接入和使用中遇到其他问题，请参见 常见问题。