@astro-minimax/ai 0.9.0 → 0.9.3

package/dist/server/chat-handler.js

@@ -1,139 +1,97 @@
 import {
   createUIMessageStream,
-  createUIMessageStreamResponse,
-  streamText,
-  convertToModelMessages
+  createUIMessageStreamResponse
 } from "ai";
 import { t, getLang } from "../utils/i18n.js";
 import {
-  getClientIP,
-  checkRateLimit,
-  rateLimitResponse,
-  searchArticles,
-  searchProjects,
-  getSessionCacheKey,
-  getCachedContext,
-  setCachedContext,
-  shouldReuseSearchContext,
   buildLocalSearchQuery,
   shouldRunKeywordExtraction,
   extractSearchKeywords,
-  KEYWORD_EXTRACTION_TIMEOUT_MS,
-  shouldSkipAnalysis,
-  analyzeRetrievedEvidence,
-  buildEvidenceSection,
-  EVIDENCE_ANALYSIS_TIMEOUT_MS,
-  getCitationGuardPreflight,
-  buildSystemPrompt,
-  getAuthorContext,
-  getVoiceProfile,
+  rankArticlesByCategory,
+  applyBudgetToArticles,
+  shouldAppendCitations,
+  selectCitations,
+  formatCitationBlock,
+  resolveSearchInterpretation
+} from "../intelligence/index.js";
+import {
   mergeResults,
-  getProviderManager,
+  searchArticles,
+  searchProjects,
+  getSessionCacheKey,
+  getCachedContext,
+  setCachedContext
+} from "../search/index.js";
+import {
+  extractCodeAnchors,
+  hasCodeAnchors,
+  normalizeText,
+  tokenize
+} from "../utils/text.js";
+import { getProviderManager } from "../provider-manager/index.js";
+import {
   createCacheAdapter,
-  detectPublicQuestion,
   getGlobalSearchCache,
-  shouldAppendCitations,
-  formatCitationBlock,
-  selectCitations,
   setGlobalSearchCache,
   getGlobalCacheTTL,
   getResponseCache,
   setResponseCache,
   getResponseCacheConfig,
-  rankArticlesByIntent,
-  matchFactsToQuery,
-  buildFactSection
-} from "../index.js";
+  detectPublicQuestion,
+  normalizePublicCacheQuery
+} from "../cache/index.js";
+import {
+  getClientIP,
+  checkRateLimit,
+  rateLimitResponse
+} from "../middleware/index.js";
+import {
+  getExtensionRegistry,
+  getSemanticFallback,
+  mergeSearchDocuments
+} from "../extensions/index.js";
+import { initializeExtensions, areExtensionsLoaded } from "./metadata-init.js";
 import { createChatStatusData } from "./types.js";
-import { errors, corsPreflightResponse } from "./errors.js";
-import { notifyAiChat } from "./notify.js";
+import { errors, corsPreflightResponse, setCorsOrigin } from "./errors.js";
 import {
   writeSearchStatus,
   writeGeneratingStatus,
   writeSourceArticles,
-  streamLLMResponse,
+  writeSourceSnippets,
+  streamAnswerWithFallback,
   streamMockFallback,
-  streamCachedResponse
+  streamCachedResponse,
+  writeTextChunk,
+  writeFinish
 } from "./stream-helpers.js";
-const MAX_HISTORY_MESSAGES = 20;
-const MAX_INPUT_LENGTH = 500;
-const REQUEST_TIMEOUT_MS = 45e3;
-function sendNotification(args) {
-  const { env, messages, responseText, relatedArticles, model, usage, timing, cacheKey, waitUntil } = args;
-  const sessionId = cacheKey || `dev-${Date.now().toString(36)}`;
-  const notifyArticles = relatedArticles.slice(0, 5).map((a) => ({
-    title: a.title,
-    url: a.url
-  }));
-  const notifyPromise = notifyAiChat({
-    env,
-    sessionId,
-    messages,
-    aiResponse: responseText,
-    referencedArticles: notifyArticles,
-    model,
-    usage,
-    timing
-  });
-  if (waitUntil) {
-    waitUntil(notifyPromise);
-  } else {
-    void notifyPromise;
-  }
-}
-function getMessageText(message) {
-  if (Array.isArray(message.parts)) {
-    return message.parts.filter((p) => p.type === "text").map((p) => p.text).join("");
-  }
-  return "";
-}
-function hasContent(message) {
-  const text = getMessageText(message);
-  if (text.trim()) return true;
-  if (Array.isArray(message.parts)) {
-    return message.parts.some((p) => p.type !== "text");
-  }
-  return false;
-}
-function filterValidMessages(messages) {
-  const filtered = [];
-  let lastRole = null;
-  for (const msg of messages) {
-    if (!hasContent(msg)) continue;
-    if (msg.role === lastRole) continue;
-    filtered.push(msg);
-    lastRole = msg.role;
-  }
-  if (filtered.length > 0 && filtered[filtered.length - 1].role !== "user") {
-    filtered.pop();
-  }
-  return filtered;
-}
-function buildArticleContextPrompt(context) {
-  if (context.scope !== "article" || !context.article) return "";
-  const a = context.article;
-  const parts = [
-    "\n[\u5F53\u524D\u9605\u8BFB\u6587\u7AE0]",
-    `\u7528\u6237\u6B63\u5728\u9605\u8BFB\uFF1A\u300A${a.title}\u300B`
-  ];
-  if (a.summary) parts.push(`\u6458\u8981\uFF1A${a.summary}`);
-  if (a.abstract) parts.push(`\u8BE6\u7EC6\u6982\u8981\uFF1A${a.abstract}`);
-  if (a.keyPoints?.length) parts.push(`\u6838\u5FC3\u8981\u70B9\uFF1A${a.keyPoints.join("\uFF1B")}`);
-  if (a.categories?.length) parts.push(`\u5206\u7C7B\uFF1A${a.categories.join("\u3001")}`);
-  parts.push(
-    "",
-    "\u4F60\u6B63\u5728\u966A\u7528\u6237\u9605\u8BFB\u8FD9\u7BC7\u6587\u7AE0\u3002\u4F18\u5148\u56F4\u7ED5\u8FD9\u7BC7\u6587\u7AE0\u7684\u5185\u5BB9\u56DE\u7B54\u95EE\u9898\u3002",
-    "\u5F53\u7528\u6237\u7684\u95EE\u9898\u4E0E\u5F53\u524D\u6587\u7AE0\u76F8\u5173\u65F6\uFF0C\u5F15\u7528\u6587\u7AE0\u4E2D\u7684\u5177\u4F53\u5185\u5BB9\u3002",
-    "\u5F53\u7528\u6237\u60F3\u8981\u5EF6\u4F38\u65F6\uFF0C\u63A8\u8350\u76F8\u5173\u7684\u535A\u5BA2\u6587\u7AE0\u3002"
-  );
-  return parts.join("\n");
-}
+import {
+  getMessageText,
+  filterValidMessages,
+  getLatestUserText
+} from "./chat-message-utils.js";
+import {
+  sendNotification,
+  getTimeoutConfig,
+  getHealthConfig
+} from "./chat-utils.js";
+import {
+  assemblePromptRuntime
+} from "./prompt-runtime.js";
+import { CHAT_HANDLER, RESPONSE } from "../constants.js";
+import { createLogger, setLogLevel } from "../utils/logger.js";
+import { getAllTools } from "../tools/index.js";
+const log = createLogger("chat-handler");
 async function handleChatRequest(options) {
   const { env, request: req, waitUntil } = options;
+  if (env.AI_DEBUG) setLogLevel("debug");
+  if (env.CORS_ORIGIN) setCorsOrigin(env.CORS_ORIGIN);
   if (req.method === "OPTIONS") return corsPreflightResponse();
   if (req.method !== "POST") return errors.methodNotAllowed("zh");
   const ip = getClientIP(req);
-  const rateCheck = checkRateLimit(ip, env);
+  const rateCheck = checkRateLimit(
+    ip,
+    env
+  );
   if (!rateCheck.allowed) return rateLimitResponse(rateCheck, "zh");
   let body;
   try {
@@ -143,116 +101,349 @@ async function handleChatRequest(options) {
   }
   const lang = getLang(body.lang ?? env.SITE_LANG);
   const context = body.context ?? { scope: "global" };
-  const rawMessages = (body.messages ?? []).slice(-MAX_HISTORY_MESSAGES);
+  const rawMessages = (body.messages ?? []).slice(
+    -CHAT_HANDLER.MAX_HISTORY_MESSAGES
+  );
   if (!rawMessages.length) return errors.emptyMessage(lang);
   const messages = filterValidMessages(rawMessages);
   if (!messages.length) return errors.emptyMessage(lang);
   const latestMessage = messages[messages.length - 1];
-  const latestText = getMessageText(latestMessage);
+  const latestText = latestMessage.role === "user" ? getMessageText(latestMessage) : getLatestUserText(messages);
   if (!latestText) return errors.emptyContent(lang);
-  if (latestText.length > MAX_INPUT_LENGTH) return errors.inputTooLong(MAX_INPUT_LENGTH, lang);
+  if (latestText.length > CHAT_HANDLER.MAX_INPUT_LENGTH)
+    return errors.inputTooLong(CHAT_HANDLER.MAX_INPUT_LENGTH, lang);
+  const timeouts = getTimeoutConfig(env);
   const requestAbort = new AbortController();
-  const requestTimer = setTimeout(() => requestAbort.abort(), REQUEST_TIMEOUT_MS);
+  const requestTimer = setTimeout(() => requestAbort.abort(), timeouts.request);
+  log.debug(
+    `Request: scope=${context.scope}, msg="${latestText.substring(0, 80)}", history=${messages.length}`
+  );
   try {
-    return await runPipeline({ env, messages, latestText, context, req, requestAbort, lang, waitUntil });
+    return await runPipeline({
+      env,
+      messages,
+      latestText,
+      context,
+      req,
+      requestAbort,
+      lang,
+      waitUntil,
+      timeouts
+    });
   } catch (err) {
     if (requestAbort.signal.aborted) return errors.timeout(lang);
-    console.error("[chat-handler] Unexpected error:", err);
+    log.error("Unexpected error:", err);
     return errors.internal(void 0, lang);
   } finally {
     clearTimeout(requestTimer);
   }
 }
-async function runPipeline(args) {
-  const { env, messages, latestText, context, req, lang, waitUntil } = args;
+async function initializeContext(args) {
+  const { env, messages, latestText, context, req, lang, timeouts } = args;
   const timing = { start: Date.now() };
   const cache = createCacheAdapter(env);
   const responseCacheConfig = getResponseCacheConfig(env);
+  const healthConfig = getHealthConfig(env);
   const manager = getProviderManager(env, {
     enableMockFallback: true,
-    unhealthyThreshold: 3,
-    healthRecoveryTTL: 6e4
+    unhealthyThreshold: healthConfig.unhealthyThreshold,
+    healthRecoveryTTL: healthConfig.recoveryTtl
   });
   const hasRealProvider = manager.hasProviders();
-  const adapter = hasRealProvider ? await manager.getAvailableAdapter() : null;
+  const adapters = hasRealProvider ? await manager.getAvailableAdapters() : [];
+  const adapter = adapters[0] ?? null;
+  if (!areExtensionsLoaded()) {
+    await initializeExtensions();
+  }
+  const extensions = getExtensionRegistry().getLoadedExtensions();
   const articleSlug = context.scope === "article" && context.article?.slug ? context.article.slug : void 0;
   const publicQuestion = detectPublicQuestion(latestText);
-  let globalCacheHit = false;
-  let globalCacheType;
-  if (publicQuestion && (!publicQuestion.needsContext || articleSlug)) {
-    const globalCacheContext = { articleSlug, lang };
-    if (responseCacheConfig.enabled) {
-      const cachedResponse = await getResponseCache(cache, publicQuestion.type, globalCacheContext);
-      if (cachedResponse) {
-        globalCacheHit = true;
-        globalCacheType = publicQuestion.type;
-        const notifyTiming = { total: Date.now() - timing.start };
-        sendNotification({ env, messages, responseText: cachedResponse.response, relatedArticles: cachedResponse.articles, timing: notifyTiming, waitUntil });
-        const stream2 = createUIMessageStream({
-          execute: async ({ writer }) => {
-            await streamCachedResponse(writer, cachedResponse, responseCacheConfig, lang);
-          }
-        });
-        return createUIMessageStreamResponse({ stream: stream2, headers: { "Access-Control-Allow-Origin": "*", "Cache-Control": "no-cache" } });
-      }
+  const cacheKey = getSessionCacheKey(req);
+  return {
+    env,
+    messages,
+    latestText,
+    context,
+    lang,
+    timeouts,
+    timing,
+    cache,
+    responseCacheConfig,
+    adapters,
+    adapter,
+    hasRealProvider,
+    extensions,
+    articleSlug,
+    publicQuestion,
+    cacheKey
+  };
+}
+async function analyzeAndBuildPrompt(ctx, search) {
+  return assemblePromptRuntime({
+    env: ctx.env,
+    latestText: ctx.latestText,
+    context: ctx.context,
+    lang: ctx.lang,
+    evidenceAnalysisTimeout: ctx.timeouts.evidenceAnalysis,
+    timing: {
+      total: Date.now() - ctx.timing.start,
+      keywordExtraction: ctx.timing.keywordExtraction,
+      search: ctx.timing.search,
+      evidenceAnalysis: ctx.timing.evidenceAnalysis,
+      generation: ctx.timing.generation
+    },
+    adapter: ctx.adapter,
+    hasRealProvider: ctx.hasRealProvider,
+    extensions: ctx.extensions,
+    cacheKey: ctx.cacheKey,
+    searchQuery: search.searchQuery,
+    relatedArticles: search.relatedArticles,
+    relatedProjects: search.relatedProjects,
+    budget: search.budget,
+    answerMode: search.interpretation.answer.contract
+  });
+}
+function resolveSearchAnswerShaping(query) {
+  const { interpretation, budget } = resolveSearchInterpretation({
+    latestText: query
+  });
+  return { interpretation, budget };
+}
+function rankArticlesForQuery(query, articles) {
+  const { interpretation } = resolveSearchInterpretation({ latestText: query });
+  return rankArticlesByCategory(interpretation.topic.primary, articles);
+}
+const MIN_QUOTED_QUERY_LENGTH = 12;
+const CURRENT_ARTICLE_SCORE_BOOST_RATIO = 0.12;
+const CURRENT_ARTICLE_SCORE_CAP_RATIO = 1.08;
+const CROSS_ARTICLE_INTENT_PATTERNS = [
+  /还有哪些/u,
+  /相关文章/u,
+  /类似/u,
+  /推荐/u,
+  /对比/u,
+  /比较/u,
+  /related/u,
+  /similar/u,
+  /compare/u,
+  /comparison/u,
+  /recommend/u,
+  /what else/u
+];
+function extractQuotedCandidate(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return "";
+  const matches = [...trimmed.matchAll(/["“”'‘’「」『』《》](.+?)["“”'‘’「」『』《》]/g)].map((match) => match[1]?.trim() ?? "").filter(Boolean).sort((a, b) => b.length - a.length);
+  return matches[0] ?? "";
+}
+function isLikelyQuotedArticleQuery(text) {
+  const quoted = extractQuotedCandidate(text);
+  if (!quoted) return false;
+  return normalizeText(quoted).length >= MIN_QUOTED_QUERY_LENGTH;
+}
+function isCrossArticleIntent(text) {
+  if (isLikelyQuotedArticleQuery(text)) {
+    return false;
+  }
+  const normalized = normalizeText(text);
+  if (!normalized) return false;
+  return CROSS_ARTICLE_INTENT_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+function isCurrentArticle(article, articleSlug) {
+  return article.id === articleSlug || article.url?.includes(articleSlug);
+}
+function buildCurrentArticleFallback(context, articleSlug, tailScore) {
+  if (context?.scope !== "article" || !context.article) return null;
+  return {
+    id: articleSlug,
+    title: context.article.title,
+    url: `/posts/${articleSlug}`,
+    summary: context.article.summary ?? context.article.abstract,
+    keyPoints: context.article.keyPoints ?? [],
+    categories: context.article.categories ?? [],
+    dateTime: 0,
+    score: tailScore
+  };
+}
+function rerankArticlesForCurrentArticleQuote(query, articles, options = {}) {
+  const { articleSlug, context } = options;
+  if (!articleSlug || context?.scope !== "article") return articles;
+  if (!isLikelyQuotedArticleQuery(query)) return articles;
+  if (isCrossArticleIntent(query)) return articles;
+  const cloned = [...articles];
+  const currentIndex = cloned.findIndex(
+    (article) => isCurrentArticle(article, articleSlug)
+  );
+  if (currentIndex >= 0) {
+    const topScore = cloned[0]?.score ?? 0;
+    if (topScore <= 0) return cloned;
+    const current = cloned[currentIndex];
+    const boostedScore = Math.min(
+      (current.score ?? 0) + topScore * CURRENT_ARTICLE_SCORE_BOOST_RATIO,
+      topScore * CURRENT_ARTICLE_SCORE_CAP_RATIO
+    );
+    cloned[currentIndex] = { ...current, score: boostedScore };
+    return cloned.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+  }
+  const tailScore = Math.max((cloned[cloned.length - 1]?.score ?? 1) * 0.95, 0.01);
+  const fallback = buildCurrentArticleFallback(context, articleSlug, tailScore);
+  if (!fallback) return cloned;
+  return [...cloned, fallback];
+}
+function shapeArticlesForQuery(query, articles, options = {}) {
+  const { interpretation, budget } = resolveSearchInterpretation({
+    latestText: query
+  });
+  const boostedArticles = rerankArticlesForCurrentArticleQuote(
+    query,
+    articles,
+    options
+  );
+  const rankedArticles = hasCodeAnchors(query) ? rerankArticlesForCodeAnchors(query, boostedArticles) : rankArticlesByCategory(interpretation.topic.primary, boostedArticles);
+  return {
+    interpretation,
+    budget,
+    articles: applyBudgetToArticles(rankedArticles, budget)
+  };
+}
+function rerankArticlesForCodeAnchors(query, articles) {
+  const rawAnchors = extractCodeAnchors(query);
+  if (rawAnchors.length === 0 || articles.length <= 1) return articles;
+  return [...articles].sort((a, b) => {
+    const aAnchorScore = scoreArticleForCodeAnchors(a, rawAnchors);
+    const bAnchorScore = scoreArticleForCodeAnchors(b, rawAnchors);
+    return bAnchorScore - aAnchorScore || (b.score ?? 0) - (a.score ?? 0) || a.title.localeCompare(b.title);
+  });
+}
+function scoreArticleForCodeAnchors(article, rawAnchors) {
+  const title = article.title;
+  const summary = article.summary ?? "";
+  const keyPoints = article.keyPoints ?? [];
+  const chunks = article.chunks ?? [];
+  let score = 0;
+  for (const anchor of rawAnchors) {
+    const normalizedAnchor = normalizeText(anchor);
+    if (!normalizedAnchor) continue;
+    if (title.includes(anchor)) {
+      score += 10;
+      continue;
     }
-    const cachedSearch = await getGlobalSearchCache(cache, publicQuestion.type, globalCacheContext);
-    if (cachedSearch) {
-      globalCacheHit = true;
-      globalCacheType = publicQuestion.type;
-      const stream2 = createUIMessageStream({
-        execute: async ({ writer }) => {
-          const w = writer;
-          writeSearchStatus(w, cachedSearch.articles.length + cachedSearch.projects.length, lang);
-          if (cachedSearch.articles.length + cachedSearch.projects.length > 0) {
-            writeGeneratingStatus(w, lang);
-          }
-          writeSourceArticles(w, cachedSearch.articles);
-          let responseText = "";
-          if (adapter) {
-            const articlePrompt2 = buildArticleContextPrompt(context);
-            const matchedFacts2 = matchFactsToQuery(cachedSearch.query, lang);
-            const factPromptSection2 = buildFactSection(matchedFacts2, lang);
-            const systemPrompt2 = buildSystemPrompt({
-              static: { authorName: env.SITE_AUTHOR || "\u535A\u4E3B", siteUrl: env.SITE_URL || "", lang },
-              semiStatic: { authorContext: getAuthorContext(), voiceProfile: getVoiceProfile() },
-              dynamic: { userQuery: cachedSearch.query, articles: cachedSearch.articles, projects: cachedSearch.projects, evidenceSection: articlePrompt2, factSection: factPromptSection2 }
-            });
-            const llmResult = await streamLLMResponse({ writer: w, adapter, systemPrompt: systemPrompt2, messages, lang });
-            responseText = llmResult.responseText;
-            if (responseCacheConfig.enabled && llmResult.success && llmResult.responseText.length > 0) {
-              const globalTTL = getGlobalCacheTTL(publicQuestion.type);
-              const responseCacheData = {
-                query: cachedSearch.query,
-                thinking: llmResult.reasoningText,
-                response: llmResult.responseText,
-                articles: cachedSearch.articles,
-                projects: cachedSearch.projects,
-                lang,
-                model: adapter.model,
-                updatedAt: Date.now()
-              };
-              await setResponseCache(cache, publicQuestion.type, responseCacheData, globalTTL, globalCacheContext);
-            }
-          } else {
-            responseText = await streamMockFallback(w, latestText, lang);
-          }
-        }
-      });
-      return createUIMessageStreamResponse({ stream: stream2, headers: { "Access-Control-Allow-Origin": "*", "Cache-Control": "no-cache" } });
+    if (summary.includes(anchor)) {
+      score += 6;
+      continue;
+    }
+    if (keyPoints.some((point) => point.includes(anchor))) {
+      score += 5;
+      continue;
+    }
+    if (chunks.some((chunk) => chunk.heading.includes(anchor))) {
+      score += 8;
+      continue;
+    }
+    if (chunks.some((chunk) => chunk.content.includes(anchor))) {
+      score += 9;
+      continue;
+    }
+    const normalizedTitle = normalizeText(title);
+    const normalizedSummary = normalizeText(summary);
+    const normalizedKeyPoints = keyPoints.map((point) => normalizeText(point));
+    if (normalizedTitle.includes(normalizedAnchor)) {
+      score += 6;
+    } else if (normalizedSummary.includes(normalizedAnchor)) {
+      score += 4;
+    } else if (normalizedKeyPoints.some((point) => point.includes(normalizedAnchor))) {
+      score += 3;
+    } else if (chunks.some(
+      (chunk) => normalizeText(chunk.heading).includes(normalizedAnchor) || normalizeText(chunk.content).includes(normalizedAnchor)
+    )) {
+      score += 5;
     }
   }
-  const cacheKey = getSessionCacheKey(req);
+  return score;
+}
+function shouldPersistAuthoritativeSources(sources) {
+  return sources.length > 0 && sources.every(
+    (source) => source.reason === "chunk" || source.reason === "evidence" || source.reason === "article-context"
+  );
+}
+function shapeCachedSearchForQuery(args) {
+  const shaped = shapeArticlesForQuery(args.query, args.articles);
+  return {
+    interpretation: shaped.interpretation,
+    budget: shaped.budget,
+    articles: shaped.articles,
+    projects: args.projects
+  };
+}
+function shouldPersistResponseCacheEntry(args) {
+  return args.enabled && args.success && args.responseText.length > 0 && shouldPersistAuthoritativeSources(args.sources);
+}
+function shouldUsePublicQuestionCaches(args) {
+  return Boolean(args.publicQuestion && (!args.publicQuestion.needsContext || args.articleSlug));
+}
+function buildPublicCacheContext(args) {
+  return {
+    articleSlug: args.articleSlug,
+    lang: args.lang,
+    queryKey: normalizePublicCacheQuery(args.latestText)
+  };
+}
+function shapePublicCacheBranch(args) {
+  return {
+    enabled: shouldUsePublicQuestionCaches({
+      publicQuestion: args.publicQuestion,
+      articleSlug: args.articleSlug
+    }),
+    context: buildPublicCacheContext({
+      articleSlug: args.articleSlug,
+      lang: args.lang,
+      latestText: args.latestText
+    })
+  };
+}
+async function retrieveContext(ctx, req) {
+  const {
+    messages,
+    latestText,
+    cache,
+    timeouts,
+    timing,
+    hasRealProvider,
+    adapter,
+    extensions,
+    publicQuestion,
+    articleSlug,
+    cacheKey,
+    lang
+  } = ctx;
   const now = Date.now();
   const cachedContext = cacheKey ? await getCachedContext(cacheKey, cache) : void 0;
-  const userTurnCount = messages.filter((m) => m.role === "user").length;
-  const reuseContext = shouldReuseSearchContext({ latestText, cachedContext, userTurnCount, now });
+  const userTurnCount = messages.filter(
+    (m) => m.role === "user"
+  ).length;
+  const initialSearchInterpretation = resolveSearchInterpretation({
+    latestText,
+    cachedContext,
+    userTurnCount,
+    now
+  });
+  const reuseContext = initialSearchInterpretation.interpretation.conversation.shouldReuseContext;
   let searchQuery = buildLocalSearchQuery(latestText) || latestText;
   let relatedArticles = reuseContext && cachedContext ? cachedContext.articles : [];
   let relatedProjects = reuseContext && cachedContext ? cachedContext.projects : [];
+  let { budget } = initialSearchInterpretation;
+  let { interpretation } = initialSearchInterpretation;
+  const semanticFallback = getSemanticFallback(latestText, extensions);
+  if (semanticFallback) {
+    searchQuery = semanticFallback.query;
+  }
   if (reuseContext && cachedContext && cacheKey) {
     searchQuery = cachedContext.query;
-    await setCachedContext(cacheKey, { ...cachedContext, updatedAt: now }, cache);
+    await setCachedContext(
+      cacheKey,
+      { ...cachedContext, updatedAt: now },
+      cache
+    );
   } else {
     if (hasRealProvider && adapter) {
       const runKW = shouldRunKeywordExtraction({
@@ -263,7 +454,10 @@ async function runPipeline(args) {
       if (runKW) {
         const kwStart = Date.now();
         const abortCtrl = new AbortController();
-        const timeoutId = setTimeout(() => abortCtrl.abort(), KEYWORD_EXTRACTION_TIMEOUT_MS);
+        const timeoutId = setTimeout(
+          () => abortCtrl.abort(),
+          timeouts.keywordExtraction
+        );
         try {
           const provider = adapter.getProvider();
           const kwResult = await extractSearchKeywords({
@@ -277,7 +471,9 @@ async function runPipeline(args) {
             searchQuery = kwResult.query;
             if (kwResult.primaryQuery && kwResult.primaryQuery !== searchQuery) {
               const searchStart = Date.now();
-              const primary = searchArticles(kwResult.primaryQuery, { enableDeepContent: false });
+              const primary = searchArticles(kwResult.primaryQuery, {
+                enableDeepContent: false
+              });
               relatedArticles = mergeResults(
                 searchArticles(searchQuery, { enableDeepContent: true }),
                 primary
@@ -286,8 +482,12 @@ async function runPipeline(args) {
               timing.search = Date.now() - searchStart;
             }
           }
-        } catch {
+        } catch (err) {
           timing.keywordExtraction = Date.now() - kwStart;
+          console.debug(
+            "[chat-handler] Keyword extraction failed, using local query:",
+            err.message
+          );
         } finally {
           clearTimeout(timeoutId);
         }
@@ -295,20 +495,31 @@ async function runPipeline(args) {
     }
     if (!relatedArticles.length) {
       const searchStart = Date.now();
-      relatedArticles = searchArticles(searchQuery, { enableDeepContent: true });
+      relatedArticles = searchArticles(searchQuery, {
+        enableDeepContent: true
+      });
       relatedProjects = searchProjects(searchQuery);
       timing.search = Date.now() - searchStart;
     }
-    relatedArticles = rankArticlesByIntent(latestText, relatedArticles);
     if (cacheKey) {
-      await setCachedContext(cacheKey, {
-        query: searchQuery,
-        articles: relatedArticles,
-        projects: relatedProjects,
-        updatedAt: now
-      }, cache);
+      await setCachedContext(
+        cacheKey,
+        {
+          query: searchQuery,
+          articles: relatedArticles,
+          projects: relatedProjects,
+          updatedAt: now
+        },
+        cache
+      );
     }
-    if (publicQuestion && (!publicQuestion.needsContext || articleSlug)) {
+    const publicCacheBranch = shapePublicCacheBranch({
+      publicQuestion,
+      articleSlug,
+      lang,
+      latestText
+    });
+    if (publicCacheBranch.enabled && publicQuestion) {
       const globalTTL = getGlobalCacheTTL(publicQuestion.type);
       await setGlobalSearchCache(
         cache,
@@ -320,67 +531,223 @@ async function runPipeline(args) {
           updatedAt: now
         },
         globalTTL,
-        { articleSlug, lang }
+        publicCacheBranch.context
       );
     }
   }
-  let evidenceSection = "";
-  if (hasRealProvider && adapter) {
-    const skipEvidence = shouldSkipAnalysis(latestText, relatedArticles.length, "moderate");
-    if (!skipEvidence) {
-      const evidenceStart = Date.now();
-      const abortCtrl = new AbortController();
-      const timeoutId = setTimeout(() => abortCtrl.abort(), EVIDENCE_ANALYSIS_TIMEOUT_MS);
-      try {
-        const provider = adapter.getProvider();
-        const evidenceResult = await analyzeRetrievedEvidence({
-          userQuery: latestText,
-          articles: relatedArticles,
-          projects: relatedProjects,
-          provider,
-          model: adapter.evidenceModel,
-          abortSignal: abortCtrl.signal
+  relatedArticles = mergeSearchDocuments(relatedArticles, extensions);
+  ({ interpretation, budget, articles: relatedArticles } = shapeArticlesForQuery(
+    latestText,
+    relatedArticles,
+    { articleSlug, context: ctx.context }
+  ));
+  log.debug(
+    `Search: query="${searchQuery}", articles=${relatedArticles.length}, projects=${relatedProjects.length}, mode=${interpretation.answer.contract}`
+  );
+  if (relatedArticles.length > 0) {
+    log.debug(
+      `Top articles: ${relatedArticles.slice(0, 3).map(
+        (a) => `"${a.title}" (chunks: ${a.chunks?.length ?? 0})`
+      ).join(", ")}`
+    );
+  }
+  return { searchQuery, relatedArticles, relatedProjects, budget, interpretation };
+}
+async function runPipeline(args) {
+  const ctx = await initializeContext(args);
+  const {
+    env,
+    messages,
+    latestText,
+    context,
+    lang,
+    timeouts,
+    timing,
+    cache,
+    responseCacheConfig,
+    adapters,
+    adapter,
+    hasRealProvider,
+    extensions,
+    articleSlug,
+    publicQuestion,
+    cacheKey
+  } = ctx;
+  const { waitUntil } = args;
+  const tools = getAllTools();
+  const publicCacheBranch = shapePublicCacheBranch({
+    publicQuestion,
+    articleSlug,
+    lang,
+    latestText
+  });
+  if (publicCacheBranch.enabled && publicQuestion) {
+    const globalCacheContext = publicCacheBranch.context;
+    if (responseCacheConfig.enabled) {
+      const cachedResponse = await getResponseCache(
+        cache,
+        publicQuestion.type,
+        globalCacheContext
+      );
+      if (cachedResponse) {
+        const notifyTiming = { total: Date.now() - timing.start };
+        sendNotification({
+          env,
+          messages,
+          responseText: cachedResponse.response,
+          relatedArticles: cachedResponse.articles,
+          timing: notifyTiming,
+          waitUntil
+        });
+        const stream2 = createUIMessageStream({
+          execute: async ({ writer }) => {
+            await streamCachedResponse(
+              writer,
+              cachedResponse,
+              responseCacheConfig,
+              lang
+            );
+          }
+        });
+        return createUIMessageStreamResponse({
+          stream: stream2,
+          headers: {
+            "Access-Control-Allow-Origin": "*",
+            "Cache-Control": "no-cache"
+          }
         });
-        if (evidenceResult.analysis) {
-          evidenceSection = buildEvidenceSection(evidenceResult.analysis);
-        }
-        timing.evidenceAnalysis = Date.now() - evidenceStart;
-      } catch {
-        timing.evidenceAnalysis = Date.now() - evidenceStart;
-      } finally {
-        clearTimeout(timeoutId);
       }
     }
-  }
-  const preflight = getCitationGuardPreflight({
-    userQuery: latestText,
-    articles: relatedArticles,
-    projects: relatedProjects,
-    lang
-  });
-  const matchedFacts = matchFactsToQuery(latestText, lang);
-  const factPromptSection = buildFactSection(matchedFacts, lang);
-  const articlePrompt = buildArticleContextPrompt(context);
-  const systemPrompt = buildSystemPrompt({
-    static: {
-      authorName: env.SITE_AUTHOR || "\u535A\u4E3B",
-      siteUrl: env.SITE_URL || "",
-      lang
-    },
-    semiStatic: {
-      authorContext: getAuthorContext(),
-      voiceProfile: getVoiceProfile()
-    },
-    dynamic: {
-      userQuery: searchQuery,
-      articles: relatedArticles,
-      projects: relatedProjects,
-      evidenceSection: articlePrompt ? `${evidenceSection}
-${articlePrompt}` : evidenceSection,
-      factSection: factPromptSection,
-      lang
+    const cachedSearch = await getGlobalSearchCache(
+      cache,
+      publicQuestion.type,
+      globalCacheContext
+    );
+    if (cachedSearch) {
+      const stream2 = createUIMessageStream({
+        execute: async ({ writer }) => {
+          const w = writer;
+          writeSearchStatus(
+            w,
+            cachedSearch.articles.length + cachedSearch.projects.length,
+            lang
+          );
+          if (cachedSearch.articles.length + cachedSearch.projects.length > 0) {
+            writeGeneratingStatus(w, lang);
+          }
+          let responseText = "";
+          if (adapter) {
+            const {
+              interpretation: cachedInterpretation,
+              budget: cachedBudget,
+              articles: shapedCachedArticles,
+              projects: shapedCachedProjects
+            } = shapeCachedSearchForQuery({
+              query: latestText,
+              articles: cachedSearch.articles,
+              projects: cachedSearch.projects
+            });
+            const promptRuntime = await assemblePromptRuntime({
+              env,
+              latestText,
+              context,
+              lang,
+              evidenceAnalysisTimeout: timeouts.evidenceAnalysis,
+              timing: {
+                total: Date.now() - timing.start,
+                keywordExtraction: timing.keywordExtraction,
+                search: timing.search,
+                evidenceAnalysis: timing.evidenceAnalysis,
+                generation: timing.generation
+              },
+              adapter,
+              hasRealProvider,
+              extensions,
+              cacheKey,
+              searchQuery: cachedSearch.query,
+              relatedArticles: shapedCachedArticles,
+              relatedProjects: shapedCachedProjects,
+              budget: cachedBudget,
+              answerMode: cachedInterpretation.answer.contract
+            });
+            const finalSources2 = buildFinalSources({
+              relatedArticles: shapedCachedArticles,
+              selectedSources: promptRuntime.selectedSources,
+              query: latestText,
+              lang,
+              max: RESPONSE.MAX_SOURCE_ARTICLES,
+              articleSlug,
+              context
+            });
+            writeSourceArticles(w, finalSources2);
+            writeSourceSnippets(w, finalSources2);
+            const llmResult = await streamAnswerWithFallback({
+              writer: w,
+              adapters: [adapter],
+              systemPrompt: promptRuntime.systemPrompt,
+              messages,
+              question: latestText,
+              lang,
+              tools
+            });
+            responseText = llmResult.responseText;
+            if (shouldPersistResponseCacheEntry({
+              enabled: responseCacheConfig.enabled,
+              success: llmResult.success,
+              responseText: llmResult.responseText,
+              sources: promptRuntime.selectedSources
+            })) {
+              const globalTTL = getGlobalCacheTTL(publicQuestion.type);
+              const responseCacheData = {
+                query: cachedSearch.query,
+                thinking: llmResult.reasoningText,
+                response: llmResult.responseText,
+                articles: shapedCachedArticles,
+                projects: shapedCachedProjects,
+                sources: promptRuntime.selectedSources,
+                lang,
+                model: adapter.model,
+                updatedAt: Date.now()
+              };
+              await setResponseCache(
+                cache,
+                publicQuestion.type,
+                responseCacheData,
+                globalTTL,
+                globalCacheContext
+              );
+            }
+          } else {
+            responseText = await streamMockFallback(w, latestText, lang);
+          }
+        }
+      });
+      return createUIMessageStreamResponse({
+        stream: stream2,
+        headers: {
+          "Access-Control-Allow-Origin": "*",
+          "Cache-Control": "no-cache"
+        }
+      });
     }
+  }
+  const search = await retrieveContext(ctx, args.req);
+  const { searchQuery, relatedArticles, relatedProjects, interpretation } = search;
+  const { systemPrompt, preflight, unknownRefusal, selectedSources } = await analyzeAndBuildPrompt(ctx, search);
+  const finalSources = buildFinalSources({
+    relatedArticles,
+    selectedSources,
+    query: latestText,
+    lang,
+    max: RESPONSE.MAX_SOURCE_ARTICLES,
+    articleSlug,
+    context
   });
+  log.debug(
+    `Final sources: ${finalSources.map(
+      (source) => `${source.title}[${source.reason}]${source.lang ? `:${source.lang}` : ""}`
+    ).join(", ")}`
+  );
   const stream = createUIMessageStream({
     execute: async ({ writer }) => {
       const articleCount = relatedArticles.length + relatedProjects.length;
@@ -390,36 +757,38 @@ ${articlePrompt}` : evidenceSection,
           messageMetadata: createChatStatusData({
             stage: "search",
             message: t("ai.status.found", lang, { count: articleCount }),
-            progress: 40
+            progress: RESPONSE.SEARCH_PROGRESS
           })
         });
       }
-      for (const article of relatedArticles.slice(0, 3)) {
-        try {
-          writer.write({
-            type: "source-url",
-            sourceId: `source-${article.title}`,
-            url: article.url ?? "#",
-            title: article.title
-          });
-        } catch {
-        }
-      }
+      writeSourceArticles(writer, finalSources);
+      writeSourceSnippets(writer, finalSources);
       if (preflight) {
         writer.write({
           type: "message-metadata",
           messageMetadata: createChatStatusData({
             stage: "answer",
             message: t("ai.status.citation", lang),
-            progress: 100,
+            progress: RESPONSE.COMPLETE_PROGRESS,
+            done: true
+          })
+        });
+        writeTextChunk(writer, preflight.text, "preflight");
+        writeFinish(writer);
+        return;
+      }
+      if (unknownRefusal) {
+        writer.write({
+          type: "message-metadata",
+          messageMetadata: createChatStatusData({
+            stage: "answer",
+            message: t("ai.status.generating", lang),
+            progress: RESPONSE.COMPLETE_PROGRESS,
             done: true
           })
         });
-        const partId = `preflight-${Date.now()}`;
-        writer.write({ type: "text-start", id: partId });
-        writer.write({ type: "text-delta", id: partId, delta: preflight.text });
-        writer.write({ type: "text-end", id: partId });
-        writer.write({ type: "finish", finishReason: "stop" });
+        writeTextChunk(writer, unknownRefusal.text, "unknown");
+        writeFinish(writer);
         return;
       }
       writer.write({
@@ -427,141 +796,80 @@ ${articlePrompt}` : evidenceSection,
         messageMetadata: createChatStatusData({
           stage: "answer",
           message: t("ai.status.generating", lang),
-          progress: 60
+          progress: RESPONSE.GENERATING_PROGRESS
         })
       });
-      let streamSuccess = false;
       let responseText = "";
       let reasoningText;
       let tokenUsage;
       const generationStart = Date.now();
-      if (adapter) {
-        try {
-          const provider = adapter.getProvider();
-          const result = streamText({
-            model: provider.chatModel(adapter.model),
-            system: systemPrompt,
-            messages: await convertToModelMessages(messages),
-            temperature: 0.3,
-            maxOutputTokens: 2500,
-            onError: ({ error }) => {
-              console.error("[chat-handler] streamText error:", error);
-            }
-          });
-          let hasTextOutput = false;
-          const errors2 = [];
-          writer.merge(result.toUIMessageStream({ sendFinish: false }));
-          await result.consumeStream({
-            onError: (error) => {
-              errors2.push(error instanceof Error ? error : new Error(String(error)));
-            }
-          });
-          const text = await result.text;
-          const reasoningPromise = result.reasoning;
-          const usagePromise = result.usage;
-          if (reasoningPromise) {
-            try {
-              const reasoningOutput = await Promise.resolve(reasoningPromise);
-              reasoningText = typeof reasoningOutput === "string" ? reasoningOutput : Array.isArray(reasoningOutput) ? reasoningOutput.map((r) => {
-                if (typeof r === "object" && r !== null && "text" in r) return r.text;
-                return String(r);
-              }).join("") : void 0;
-            } catch {
-            }
-          }
-          if (usagePromise) {
-            try {
-              const usage = await Promise.resolve(usagePromise);
-              const inputTokens = usage.inputTokens ?? 0;
-              const outputTokens = usage.outputTokens ?? 0;
-              tokenUsage = {
-                total: usage.totalTokens ?? inputTokens + outputTokens,
-                input: inputTokens,
-                output: outputTokens
-              };
-            } catch {
-            }
-          }
-          timing.generation = Date.now() - generationStart;
-          responseText = text;
-          hasTextOutput = text.length > 0;
-          if (hasTextOutput && errors2.length === 0) {
-            adapter.recordSuccess();
-            if (shouldAppendCitations(responseText, relatedArticles, relatedProjects)) {
-              const citations = selectCitations(relatedArticles, relatedProjects, 3, 5);
-              if (citations.length > 0) {
-                const citationBlock = formatCitationBlock(citations, lang);
-                const citationId = `citation-${Date.now()}`;
-                writer.write({ type: "text-start", id: citationId });
-                writer.write({ type: "text-delta", id: citationId, delta: citationBlock });
-                writer.write({ type: "text-end", id: citationId });
-                responseText += citationBlock;
-              }
-            }
-            writer.write({ type: "finish", finishReason: "stop" });
-            streamSuccess = true;
-            if (responseCacheConfig.enabled && publicQuestion && (!publicQuestion.needsContext || articleSlug)) {
-              const globalTTL = getGlobalCacheTTL(publicQuestion.type);
-              const responseCacheData = {
-                query: searchQuery,
-                thinking: reasoningText,
-                response: text,
-                articles: relatedArticles,
-                projects: relatedProjects,
-                lang,
-                model: adapter.model,
-                updatedAt: Date.now()
-              };
-              await setResponseCache(cache, publicQuestion.type, responseCacheData, globalTTL, { articleSlug, lang });
-            }
-          } else if (errors2.length > 0) {
-            adapter.recordFailure(errors2[0]);
-            console.error("[chat-handler] Stream error:", errors2[0].message);
-            const errorId = `error-${Date.now()}`;
-            writer.write({ type: "text-start", id: errorId });
-            writer.write({
-              type: "text-delta",
-              id: errorId,
-              delta: t("ai.error.generic", lang)
-            });
-            writer.write({ type: "text-end", id: errorId });
-            writer.write({ type: "finish", finishReason: "error" });
-            streamSuccess = true;
-          } else if (!hasTextOutput) {
-            const noOutputId = `no-output-${Date.now()}`;
-            writer.write({ type: "text-start", id: noOutputId });
-            writer.write({ type: "text-delta", id: noOutputId, delta: t("ai.error.noOutput", lang) });
-            writer.write({ type: "text-end", id: noOutputId });
-            writer.write({ type: "finish", finishReason: "stop" });
-            streamSuccess = true;
-          } else {
-            writer.write({ type: "finish", finishReason: "stop" });
-            streamSuccess = true;
+      const llmResult = await streamAnswerWithFallback({
+        writer,
+        adapters,
+        systemPrompt,
+        messages,
+        question: latestText,
+        lang,
+        temperature: CHAT_HANDLER.STREAMING_TEMPERATURE,
+        maxOutputTokens: CHAT_HANDLER.STREAMING_MAX_OUTPUT_TOKENS,
+        tools
+      });
+      timing.generation = llmResult.generationMs || Date.now() - generationStart;
+      responseText = llmResult.responseText;
+      reasoningText = llmResult.reasoningText;
+      tokenUsage = llmResult.tokenUsage ? {
+        total: llmResult.tokenUsage.total,
+        input: llmResult.tokenUsage.input,
+        output: llmResult.tokenUsage.output
+      } : void 0;
+      const usedAdapter = llmResult.adapter;
+      if (usedAdapter && llmResult.responseText.length > 0) {
+        log.debug(
+          `Provider success: adapter=${usedAdapter.id}, model=${usedAdapter.model}, responseLength=${responseText.length}, usage=${JSON.stringify(tokenUsage ?? null)}`
+        );
+        if (shouldAppendCitations(responseText, relatedArticles, relatedProjects)) {
+          const citations = selectCitations(
+            relatedArticles,
+            relatedProjects,
+            RESPONSE.MAX_SOURCE_ARTICLES,
+            RESPONSE.MAX_CITATIONS
+          );
+          if (citations.length > 0) {
+            const citationBlock = formatCitationBlock(citations, lang);
+            writeTextChunk(writer, citationBlock, "citation");
+            responseText += citationBlock;
           }
-        } catch (err) {
-          timing.generation = Date.now() - generationStart;
-          adapter.recordFailure(err instanceof Error ? err : new Error(String(err)));
-          console.error("[chat-handler] Provider threw:", err.message);
+        }
+        if (publicCacheBranch.enabled && publicQuestion && shouldPersistResponseCacheEntry({
+          enabled: responseCacheConfig.enabled,
+          success: true,
+          responseText,
+          sources: selectedSources
+        })) {
+          const globalTTL = getGlobalCacheTTL(publicQuestion.type);
+          const responseCacheData = {
+            query: searchQuery,
+            thinking: reasoningText,
+            response: responseText,
+            articles: relatedArticles,
+            projects: relatedProjects,
+            sources: selectedSources,
+            lang,
+            model: usedAdapter.model,
+            updatedAt: Date.now()
+          };
+          await setResponseCache(
+            cache,
+            publicQuestion.type,
+            responseCacheData,
+            globalTTL,
+            publicCacheBranch.context
+          );
         }
       }
-      if (!streamSuccess) {
-        const { getMockResponse } = await import("../providers/mock.js");
-        const mockText = getMockResponse(latestText, lang);
+      if (llmResult.usedMockFallback) {
         timing.generation = Date.now() - generationStart;
-        responseText = mockText;
-        writer.write({
-          type: "message-metadata",
-          messageMetadata: createChatStatusData({
-            stage: "answer",
-            message: t("ai.status.fallback", lang),
-            progress: 80
-          })
-        });
-        const fallbackId = `fallback-${Date.now()}`;
-        writer.write({ type: "text-start", id: fallbackId });
-        writer.write({ type: "text-delta", id: fallbackId, delta: mockText });
-        writer.write({ type: "text-end", id: fallbackId });
-        writer.write({ type: "finish", finishReason: "stop" });
+        responseText = llmResult.responseText;
       }
       if (responseText) {
         const notifyTiming = {
@@ -571,17 +879,16 @@ ${articlePrompt}` : evidenceSection,
           evidenceAnalysis: timing.evidenceAnalysis,
           generation: timing.generation
         };
-        const notifyModel = adapter ? {
-          name: adapter.model,
-          provider: env.AI_PROVIDER || void 0,
-          apiHost: env.AI_BASE_URL || void 0
-        } : void 0;
         sendNotification({
           env,
           messages,
           responseText,
-          relatedArticles,
-          model: notifyModel,
+          relatedArticles: finalSources,
+          model: usedAdapter ? {
+            name: usedAdapter.model,
+            provider: env.AI_PROVIDER || void 0,
+            apiHost: env.AI_BASE_URL || void 0
+          } : void 0,
           usage: tokenUsage,
           timing: notifyTiming,
           cacheKey,
@@ -598,6 +905,133 @@ ${articlePrompt}` : evidenceSection,
     }
   });
 }
+function buildFinalSources(args) {
+  const { relatedArticles, selectedSources, query, lang, max, articleSlug, context } = args;
+  const normalizedQuery = normalizeText(query);
+  const fallbackSources = relatedArticles.map((article) => ({
+    title: article.title,
+    url: article.url,
+    lang: article.lang,
+    reason: "retrieval-fallback",
+    score: article.score
+  }));
+  const preferredPool = selectedSources.length > 0 ? selectedSources : fallbackSources;
+  const isCurrentArticleSource = (source) => {
+    if (!articleSlug) return false;
+    const url = source.url ?? "";
+    if (url.includes(`/posts/${articleSlug}`) || url.includes(articleSlug)) {
+      return true;
+    }
+    if (context?.article?.title && source.title === context.article.title) {
+      return true;
+    }
+    return false;
+  };
+  const shouldPrioritizeCurrentArticle = !!articleSlug && context?.scope === "article" && isLikelyQuotedArticleQuery(query) && !isCrossArticleIntent(query);
+  if (shouldPrioritizeCurrentArticle) {
+    const orderedCurrent = preferredPool.filter(isCurrentArticleSource);
+    const orderedOther = preferredPool.filter((source) => !isCurrentArticleSource(source));
+    const currentChunkSources = orderedCurrent.filter((source) => source.reason === "chunk");
+    const currentNonChunkSources = orderedCurrent.filter((source) => source.reason !== "chunk");
+    const dedupedPrioritized = [];
+    const seenPrioritized = /* @__PURE__ */ new Set();
+    for (const source of [
+      ...currentChunkSources,
+      ...currentNonChunkSources,
+      ...orderedOther
+    ]) {
+      const key = `${source.title}::${source.url ?? ""}::${source.chunkId ?? ""}`;
+      if (seenPrioritized.has(key)) continue;
+      seenPrioritized.add(key);
+      dedupedPrioritized.push(source);
+      if (dedupedPrioritized.length >= max) break;
+    }
+    return dedupedPrioritized;
+  }
+  const sameLang = preferredPool.filter((source) => source.lang === lang);
+  const anchorTerms = tokenize(query).filter((token) => token.length >= 2).sort((a, b) => b.length - a.length).slice(0, 3);
+  const sourceMatchesAnchor = (source) => {
+    if (!anchorTerms.length) return true;
+    const title = normalizeText(source.title);
+    return anchorTerms.some((term) => title.includes(term));
+  };
+  const sameLangAnchored = sameLang.filter(sourceMatchesAnchor);
+  const crossLangAnchored = preferredPool.filter(
+    (source) => source.lang !== lang && sourceMatchesAnchor(source)
+  );
+  const articleSummaryQuery = isArticleSummaryQuery(normalizedQuery);
+  const rankByTitleCloseness = (sources) => {
+    return [...sources].sort((a, b) => {
+      const aScore = computeTitleCloseness(normalizedQuery, a.title);
+      const bScore = computeTitleCloseness(normalizedQuery, b.title);
+      return bScore - aScore || (b.score ?? 0) - (a.score ?? 0);
+    });
+  };
+  const orderedSameLang = rankByTitleCloseness(
+    sameLangAnchored.length > 0 ? sameLangAnchored : sameLang
+  );
+  const orderedCrossLang = rankByTitleCloseness(
+    crossLangAnchored.length > 0 ? crossLangAnchored : preferredPool.filter((source) => source.lang !== lang)
+  );
+  let ordered = articleSummaryQuery ? orderedSameLang.length >= max ? orderedSameLang : [...orderedSameLang, ...orderedCrossLang] : [...orderedSameLang, ...orderedCrossLang];
+  const deduped = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const source of ordered) {
+    const key = `${source.title}::${source.url ?? ""}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    deduped.push(source);
+    if (deduped.length >= max) break;
+  }
+  return deduped;
+}
+function isArticleSummaryQuery(normalizedQuery) {
+  return [
+    "\u8FD9\u7BC7\u6587\u7AE0",
+    "\u4E3B\u8981\u8BB2\u4E86\u4EC0\u4E48",
+    "\u8BB2\u4E86\u4EC0\u4E48",
+    "\u6587\u7AE0\u4E3B\u8981",
+    "\u6587\u7AE0\u8BB2\u4E86\u4EC0\u4E48",
+    "article summary",
+    "what does this article",
+    "what is this article about"
+  ].some((marker) => normalizedQuery.includes(marker));
+}
+function computeTitleCloseness(normalizedQuery, title) {
+  const normalizedTitle = normalizeText(title);
+  const tokens = tokenize(normalizedQuery).filter((token) => token.length >= 2).sort((a, b) => b.length - a.length).slice(0, 5);
+  let score = 0;
+  for (const token of tokens) {
+    if (normalizedTitle.includes(token)) {
+      score += Math.max(1, Math.min(token.length, 6));
+    }
+  }
+  if (normalizedQuery.includes("\u6280\u672F\u67B6\u6784") && normalizedTitle.includes("\u6280\u672F\u67B6\u6784")) {
+    score += 8;
+  }
+  if (normalizedQuery.includes("\u6A21\u5757") && normalizedTitle.includes("\u6A21\u5757")) {
+    score += 4;
+  }
+  if (normalizedQuery.includes("\u6587\u7AE0") && normalizedTitle.includes("\u6587\u7AE0")) {
+    score += 2;
+  }
+  return score;
+}
 export {
-  handleChatRequest
+  buildFinalSources,
+  buildPublicCacheContext,
+  extractQuotedCandidate,
+  handleChatRequest,
+  isCrossArticleIntent,
+  isLikelyQuotedArticleQuery,
+  rankArticlesForQuery,
+  rerankArticlesForCodeAnchors,
+  rerankArticlesForCurrentArticleQuote,
+  resolveSearchAnswerShaping,
+  shapeArticlesForQuery,
+  shapeCachedSearchForQuery,
+  shapePublicCacheBranch,
+  shouldPersistAuthoritativeSources,
+  shouldPersistResponseCacheEntry,
+  shouldUsePublicQuestionCaches
 };