|

1
const ALLOWED_ORIGINS = ["https://upxuu.com"];
2

3
function corsHeaders(request) {
4
  const origin = request?.headers?.get("Origin") || "";
5
  const allowOrigin = ALLOWED_ORIGINS.includes(origin) ? origin : "null";
6
  return {
7
    "Access-Control-Allow-Origin": allowOrigin,
8
    "Access-Control-Allow-Methods": "POST, OPTIONS",
9
    "Access-Control-Allow-Headers": "Content-Type",
10
  };
11
}

1
用户请求
2
  │
3
  ├─ 尝试模型 A ── 成功 ──▶ 流式渲染
4
  │     │
5
  │     └─ 失败 ──▶ 尝试模型 B ── 成功 ──▶ 流式渲染
6
  │                      │
7
  │                      └─ 失败 ──▶ 尝试模型 C
8
  │                                    │
9
  │                                    └─ 失败 ──▶ 提示"请求速率过快"
10
  └─ 更新 localStorage 记录当前模型索引

1
async function retryWithModel(startIdx) {
2
  let resp = null;
3
  let usedIdx = -1;
4
  // 从当前索引向后尝试
5
  for (let i = startIdx; i < models.length; i++) {
6
    resp = await fetch(models[i].url);
7
    if (resp?.ok) { usedIdx = i; break; }
8
  }
9
  // 兜底：从头尝试到当前索引
10
  if (!resp?.ok) {
11
    for (let i = 0; i < startIdx; i++) {
12
      resp = await fetch(models[i].url);
13
      if (resp?.ok) { usedIdx = i; break; }
14
    }
15
  }
16
  if (!resp?.ok) { /* 显示错误提示 */ return; }
17
  // 更新模型索引，开始流式渲染
18
  summaryModelIdx = usedIdx;
19
  localStorage.setItem('xuai-summary-model', String(usedIdx));
20
  await streamSummary(resp, models[usedIdx].name);
21
}

1
用户输入问题
2
  │
3
  ▼
4
前端构建请求 { articleUrl, messages }
5
  │
6
  ▼
7
Cloudflare Worker 接收请求
8
  │
9
  ├─ 1. 从 GitHub Raw 拉取 articles-index.json（博客文章索引）
10
  │
11
  ├─ 2. 从 articleUrl 提取 slug
12
  │     └─ 拉取对应文章的 Markdown 原始内容
13
  │
14
  ├─ 3. 构建 System Prompt
15
  │     ├─ SYSTEM_PROMPT（角色定义 + 输出格式）
16
  │     ├─ UPXUU_BIO（博主简介）
17
  │     ├─ 文章索引列表
18
  │     ├─ 当前文章章节引用编号
19
  │     └─ 当前文章全文（Markdown）
20
  │
21
  ├─ 4. 调用 callModel() → 上游 API
22
  │
23
  └─ 5. 透传 SSE 流 → 浏览器

1
let systemMsg = `${SYSTEM_PROMPT}\n\n${UPXUU_BIO}\n\n## 博客文章总览\n${formatArticleIndex(articles)}`;
2

3
if (articleContent) {
4
  const citeGuide = sectionIndex
5
    ? `\n\n## 当前文章章节索引\n${sectionIndex}`
6
    : "";
7
  systemMsg += `${citeGuide}\n\n## 当前文章内容\n\`\`\`markdown\n${articleContent}\n\`\`\``;
8
}

1
function getArticleHeadings() {
2
  const el = document.getElementById('article-headings-data');
3
  if (!el?.textContent) return [];
4
  return el.textContent.split('|').filter(Boolean).map(s => JSON.parse(s));
5
}
6

7
// 渲染引用链接
8
if (item.r?.length && headings.length) {
9
  for (const n of item.r) {
10
    const h = headings[n - 1];
11
    if (h) {
12
      citeHtml += `<a class="cite-link" href="#${h.slug}">${h.text}<span class="cite-arrow">↗</span></a> `;
13
    }
14
  }
15
}

1
页面加载 / 切换模型
2
  │
3
  ├─ 检查 sessionStorage 缓存
4
  │     ├─ 命中 → 直接渲染缓存结果
5
  │     └─ 未命中 → 发起请求
6
  │
7
  ├─ POST { articleUrl } → Worker
8
  │
9
  ├─ Worker 处理：
10
  │     ├─ 提取 slug → 拉取 Markdown
11
  │     ├─ 构建章节索引
12
  │     ├─ 组装 SUMMARIZE_PROMPT + 文章内容
13
  │     └─ callModel() → SSE 流
14
  │
15
  ├─ 前端流式渲染：
16
  │     ├─ thinking 过程（可折叠）
17
  │     ├─ 正文段落（支持行内 Markdown）
18
  │     ├─ 引用链接
19
  │     └─ 提问建议标签
20
  │
21
  └─ 写入 sessionStorage

1
toggle.onclick = () => {
2
  summaryModelIdx = i;
3
  localStorage.setItem('xuai-summary-model', String(i));
4
  renderSummaryModelSelector();
5
  // 重置 UI 状态
6
  startTime = Date.now();
7
  loadingEl.classList.remove('hidden');
8
  box.classList.add('hidden');
9
  resultEl.classList.add('hidden');
10
  // 重新生成
11
  retryWithModel(i);
12
};

1
// SSE 解析核心逻辑
2
async function streamSummary(resp, modelName) {
3
  const reader = resp.body?.getReader();
4
  const decoder = new TextDecoder();
5
  let buf = '';
6
  let full = '';
7
  let hasContent = false;
8
  let usage = null;
9

10
  while (true) {
11
    const { done, value } = await reader.read();
12
    if (done) break;
13

14
    buf += decoder.decode(value, { stream: true });
15
    const lines = buf.split('\n');
16
    buf = lines.pop() || '';
17

18
    for (const line of lines) {
19
      if (!line.startsWith('data: ')) continue;
20
      const data = line.slice(6).trim();
21
      if (data === '[DONE]') continue;
22

23
      const parsed = JSON.parse(data);
24
      if (parsed.usage) { usage = parsed.usage; } // 注意：不可 continue！
25
      const d = parsed.choices?.[0]?.delta;
26

27
      if (d?.reasoning_content && !hasContent) {
28
        // 渲染 thinking 过程
29
        thinkingText.textContent += d.reasoning_content;
30
      }
31
      if (d?.content) {
32
        if (!hasContent) {
33
          hasContent = true;
34
          loadingEl.classList.add('hidden');
35
        }
36
        full += d.content;
37
        resultEl.textContent = full; // 实时渲染
38
      }
39
    }
40
  }
41
  // 流结束后：最终解析 JSON 并渲染为结构化视图
42
  if (full) {
43
    sessionStorage.setItem(cacheKey, full);
44
    renderSummary(full, usage?.completion_tokens, modelName);
45
  }
46
}

1
NVIDIA SSE 流（正常）：
2
  data: {"choices":[{"delta":{"content":"..."}}]}
3
  data: {"choices":[{"delta":{"content":"..."}}]}
4
  data: {"usage":{"completion_tokens":100}}  ← 仅在末帧
5

6
SiliconFlow SSE 流（异常行为）：
7
  data: {"choices":[{"delta":{"reasoning_content":"..."}}], "usage":{...}}  ← 每帧都有
8
  data: {"choices":[{"delta":{"content":"..."}}], "usage":{...}}           ← 每帧都有
9
  data: {"usage":{"completion_tokens":500}}                                ← 末帧

1
window.setupAiSummary = setupAiSummary;
2
setupAiSummary();

1
window.swup.hooks.on('page:view', () => {
2
  if (window.setupAiSummary) window.setupAiSummary();
3
});

1
Swup 页面切换生命周期
2
  ┌──────────────────────┐
3
  │ 首次加载              │
4
  │ 脚本执行 → setupAiSummary() │
5
  │ window.setupAiSummary = fn │
6
  └──────────┬───────────┘
7
             │ 用户点击另一篇文章
8
             ▼
9
  ┌──────────────────────┐
10
  │ Swup 获取新页面 HTML   │
11
  │ Swup 替换 #swup-container │
12
  │ Swup 触发 page:view    │
13
  │ 钩子调用 window.setupAiSummary() │
14
  │ → 在新 DOM 上重新初始化  │
15
  └──────────────────────┘

1
if (modelConfig.api === NVIDIA_API) {
2
  timeout = setTimeout(() => controller.abort(), 2000);
3
}