页面源是你的吗？
├─ 是 ──▶ 同源反代（第 9 节），最稳，首选
└─ 否
   ├─ script-src 放行你的域名吗？
   │  ├─ 是 ──▶ JSONP + 长轮询（第 3–5 节）  ← 宿主内嵌的唯一现实解
   │  └─ 否
   │     ├─ frame-src 放行吗？ ──▶ iframe + postMessage 桥（第 10 节）
   │     └─ 都锁 ──▶ 找宿主加白名单，没有技术手段能绕
   └─ 你的 Worker/服务器能出网吗？
      ├─ 能 ──▶ 用它做接应点
      └─ 被上游按 IP 限 ──▶ 再加一级出口（第 6 节）

location.origin                                  // 页面在哪个源（不是你的就认命）
document.querySelector('meta[http-equiv="Content-Security-Policy"]')?.content

content-security-policy: default-src 'self'; script-src 'self' https://cdn.xxx.com; connect-src 'self'

# 服务端视角通不通
curl -i -X POST https://api.example.com/v1/x \
  -H "content-type: application/json" -d '{"q":"test"}'

<!-- 受 connect-src 管，锁了就死 -->
<script>fetch('https://relay.mydomain.com/q')</script>
<script>new WebSocket('wss://relay.mydomain.com')</script>
<script>new EventSource('https://relay.mydomain.com/sse')</script>

<!-- 受 script-src 管，connect-src 管不着 -->
<script src="https://relay.mydomain.com/q?cb=cb1"></script>

Refused to load the script 'https://relay.mydomain.com/q' because it violates
the following Content Security Policy directive: "script-src 'self'"

宿主页面
  │ <script src="https://relay.mydomain.com/q?q=你好&cb=__jp1">
  ▼
Worker（你的接应点，持上游 Key）
  │ 1. 生成 sid，把任务丢给 Durable Object 后台跑
  │ 2. 立刻返回 __jp1({"ok":true,"sid":"a1b2c3"})
  ▼
宿主页面拿到 sid，开始轮询
  │ <script src="https://relay.mydomain.com/poll?sid=a1b2c3&from=0&cb=__jp2">
  ▼
Worker → DO 取增量 → __jp2({"d":"增量文本","done":0})

// src/index.js
const CB_RE = /^[A-Za-z_$][A-Za-z0-9_$.]{0,63}$/;

function js(cb, obj) {
  return new Response(cb + '(' + JSON.stringify(obj) + ')', {
    headers: {
      'content-type': 'application/javascript; charset=utf-8',
      'cache-control': 'no-store',
      'x-content-type-options': 'nosniff',
    },
  });
}

export default {
  async fetch(req, env) {
    const u = new URL(req.url);
    const cb = u.searchParams.get('cb') || '';

    // 没 cb 就当普通 JSON 接口（方便 curl 调试）
    if (cb && !CB_RE.test(cb)) {
      return new Response('bad callback', { status: 400 });
    }

    // 只放行这两条路径，别做成任意代理
    if (u.pathname !== '/q' && u.pathname !== '/poll') {
      return new Response('not found', { status: 404 });
    }

    if (u.pathname === '/q') {
      const q = (u.searchParams.get('q') || '').slice(0, 4000);
      if (!q) return cb ? js(cb, { ok: false, err: 'empty' }) : Response.json({ ok: false, err: 'empty' });

      const sid = crypto.randomUUID().replace(/-/g, '').slice(0, 12);
      const stub = env.SESSION.get(env.SESSION.idFromName(sid));

      const t = new URL('https://do/start');
      t.searchParams.set('q', q);
      t.searchParams.set('think', u.searchParams.get('think') || '');
      await stub.fetch(t.toString());     // 内部 waitUntil，立即返回

      return cb ? js(cb, { ok: true, sid }) : Response.json({ ok: true, sid });
    }

    // /poll
    const sid = u.searchParams.get('sid') || '';
    if (!/^[a-z0-9]{6,16}$/.test(sid)) {
      return cb ? js(cb, { ok: false, err: 'bad-sid' }) : Response.json({ ok: false, err: 'bad-sid' });
    }

    const stub = env.SESSION.get(env.SESSION.idFromName(sid));
    const t = new URL('https://do/poll');
    t.searchParams.set('from', u.searchParams.get('from') || '0');
    t.searchParams.set('rfrom', u.searchParams.get('rfrom') || '0');

    const r = await stub.fetch(t.toString());
    const data = await r.text();

    return cb
      ? new Response(cb + '(' + data + ')', {
          headers: {
            'content-type': 'application/javascript; charset=utf-8',
            'cache-control': 'no-store',
            'x-content-type-options': 'nosniff',
          },
        })
      : new Response(data, { headers: { 'content-type': 'application/json' } });
  },
};

// src/session.js
export class Session {
  constructor(state, env) {
    this.state = state;
    this.env = env;
    this.text = '';
    this.reason = '';
    this.done = 0;
    this.err = '';
  }

  async fetch(req) {
    const u = new URL(req.url);
    const now = Date.now();

    if (u.pathname === '/start') {
      if (this.text || this.done) return Response.json({ ok: true });   // 幂等
      const q = u.searchParams.get('q') || '';
      const think = u.searchParams.get('think') === '1';

      // waitUntil：后台跑，不阻塞这次 fetch
      this.state.waitUntil(this.run(q, think));
      return Response.json({ ok: true });
    }

    // /poll
    const from = Math.max(0, Number(u.searchParams.get('from')) || 0);
    const rfrom = Math.max(0, Number(u.searchParams.get('rfrom')) || 0);

    // 十分钟没人取，标记过期
    if (!this.done && now - (this.at || now) > 600000) {
      this.err = this.err || 'expired';
      this.done = 1;
    }
    this.at = now;

    return Response.json({
      d: this.text.slice(from),
      rd: this.reason.slice(rfrom),
      done: this.done,
      err: this.err,
    });
  }

  async run(q, think) {
    const ctl = new AbortController();

    try {
      const up = await fetch('https://api.example.com/v1/chat', {
        method: 'POST',
        headers: {
          'content-type': 'application/json',
          authorization: 'Bearer ' + this.env.UP_KEY,
        },
        body: JSON.stringify({ q, think, stream: true }),
        signal: ctl.signal,
      });

      if (!up.ok) throw new Error('HTTP ' + up.status);

      const reader = up.body.getReader();
      const dec = new TextDecoder();
      let buf = '';

      for (;;) {
        // 20 秒没有任何新数据 → 判死，否则永远转圈
        let idle = null;
        const guard = new Promise((_, rej) => {
          idle = setTimeout(() => rej(new Error('idle-timeout')), 20000);
        });

        let it;
        try {
          it = await Promise.race([reader.read(), guard]);
        } finally {
          clearTimeout(idle);
        }

        if (it.done) break;
        buf += dec.decode(it.value, { stream: true });

        let cut;
        while ((cut = buf.indexOf('\n')) >= 0) {
          const line = buf.slice(0, cut).trim();
          buf = buf.slice(cut + 1);
          if (!line.startsWith('data:')) continue;

          const payload = line.slice(5).trim();
          if (payload === '[DONE]') { this.done = 1; return; }

          let j;
          try { j = JSON.parse(payload); } catch { continue; }
          const d = j.choices && j.choices[0] && j.choices[0].delta;
          if (!d) continue;
          if (d.reasoning_content) this.reason += d.reasoning_content;
          if (d.content) this.text += d.content;
        }
      }
      this.done = 1;
    } catch (e) {
      this.err = String((e && e.message) || e);
      this.done = 1;
    }
  }
}

name = "my-relay"
main = "src/index.js"
compatibility_date = "2026-11-01"

[[durable_objects.bindings]]
name = "SESSION"
class_name = "Session"

[[migrations]]
tag = "v1"
new_sqlite_classes = ["Session"]

[[routes]]
pattern = "relay.mydomain.com/*"
zone_name = "mydomain.com"      # 根域（已接入 Cloudflare 的那个），不是子域

wrangler secret put UP_KEY
wrangler deploy

import express from 'express';
const app = express();
const SESS = new Map();   // sid → { text, reason, done, err, at }
const CB_RE = /^[A-Za-z_$][A-Za-z0-9_$.]{0,63}$/;

function reply(req, res, payload) {
  const cb = String(req.query.cb || '');
  res.set('Cache-Control', 'no-store');
  res.set('X-Content-Type-Options', 'nosniff');
  if (!cb) return res.json(payload);
  if (!CB_RE.test(cb)) return res.status(400).type('text/plain').send('bad callback');
  res.type('application/javascript').send(`${cb}(${JSON.stringify(payload)})`);
}

app.get('/q', (req, res) => {
  const sid = Math.random().toString(36).slice(2, 12);
  const st = { text: '', reason: '', done: 0, err: '', at: Date.now() };
  SESS.set(sid, st);

  runUpstream(String(req.query.q || '').slice(0, 4000), st);   // 后台跑
  reply(req, res, { ok: true, sid });
});

app.get('/poll', (req, res) => {
  const st = SESS.get(String(req.query.sid));
  if (!st) return reply(req, res, { ok: false, err: 'no-session' });

  const from = Number(req.query.from) || 0;
  const rfrom = Number(req.query.rfrom) || 0;
  st.at = Date.now();

  reply(req, res, {
    d: st.text.slice(from),
    rd: st.reason.slice(rfrom),
    done: st.done,
    err: st.err,
  });
});

async function runUpstream(q, st) {
  try {
    const up = await fetch('https://api.example.com/v1/chat', {
      method: 'POST',
      headers: {
        'content-type': 'application/json',
        authorization: 'Bearer ' + process.env.UP_KEY,
      },
      body: JSON.stringify({ q, stream: true }),
      signal: AbortSignal.timeout(120000),
    });
    if (!up.ok) throw new Error('HTTP ' + up.status);

    const reader = up.body.getReader();
    const dec = new TextDecoder();
    let buf = '';

    for (;;) {
      const { done, value } = await reader.read();
      if (done) break;
      buf += dec.decode(value, { stream: true });

      let cut;
      while ((cut = buf.indexOf('\n')) >= 0) {
        const line = buf.slice(0, cut).trim();
        buf = buf.slice(cut + 1);
        if (!line.startsWith('data:')) continue;

        const payload = line.slice(5).trim();
        if (payload === '[DONE]') { st.done = 1; return; }

        let j;
        try { j = JSON.parse(payload); } catch { continue; }
        const d = j.choices && j.choices[0] && j.choices[0].delta;
        if (!d) continue;
        if (d.reasoning_content) st.reason += d.reasoning_content;
        if (d.content) st.text += d.content;
      }
    }
    st.done = 1;
  } catch (e) {
    st.err = String((e && e.message) || e);
    st.done = 1;
  }
}

// 十分钟清理
setInterval(() => {
  const now = Date.now();
  for (const [k, v] of SESS) if (now - v.at > 600000) SESS.delete(k);
}, 60000);

app.listen(8787);

let seq = 0;

function jsonp(url, timeout = 30000) {
  return new Promise((resolve, reject) => {
    const name = '__jp' + Date.now().toString(36) + (seq++);
    const script = document.createElement('script');
    let settled = false;

    const cleanup = () => {
      try { delete window[name]; } catch (e) { window[name] = undefined; }
      if (script.parentNode) script.parentNode.removeChild(script);
      clearTimeout(timer);
    };

    window[name] = (data) => {
      if (settled) return;
      settled = true;
      resolve(data);
      cleanup();
    };

    const timer = setTimeout(() => {
      if (settled) return;
      settled = true;
      reject(new Error('jsonp-timeout'));
      cleanup();
    }, timeout);

    script.onerror = () => {
      if (settled) return;
      settled = true;
      reject(new Error('jsonp-network'));
      cleanup();
    };

    script.src = url + (url.indexOf('?') >= 0 ? '&' : '?') + 'cb=' + name;
    script.async = true;
    document.head.appendChild(script);
  });
}

const r = await jsonp('/q?q=' + encodeURIComponent('你好'));
if (!r.ok) throw new Error(r.err);
const sid = r.sid;

// 然后轮询（第 5 节）

① GET /q?q=...&cb=        →  {ok:true, sid}        立即返回，不等结果
② GET /poll?sid&from=0    →  {d:"增量", rd:"", done:0}
③ 重复 ②，from 累加
④ done:1 或 err 非空 → 结束

const sleep = (ms) => new Promise(r => setTimeout(r, ms));

async function ask(question, onDelta, onReason, signal) {
  const start = await jsonp('/q?q=' + encodeURIComponent(question), 20000);
  if (!start.ok) throw new Error(start.err || 'start-failed');

  const sid = start.sid;
  let pos = 0, rpos = 0, idle = 0;
  const deadline = Date.now() + 180000;

  while (Date.now() < deadline) {
    if (signal && signal.aborted) throw new Error('aborted');

    const t0 = Date.now();
    const r = await jsonp(`/poll?sid=${sid}&from=${pos}&rfrom=${rpos}`, 15000);

    if (r.err) throw new Error(r.err);

    if (r.d) { onDelta(r.d); pos += r.d.length; idle = 0; }
    if (r.rd) { onReason(r.rd); rpos += r.rd.length; idle = 0; }
    if (r.done) return;

    // 没新内容 → 指数退避；有内容 → 保持 300ms 节奏
    if (!r.d && !r.rd) {
      idle++;
      await sleep(Math.min(3000, 300 * Math.pow(1.6, Math.min(idle, 6))));
    } else if (Date.now() - t0 < 300) {
      await sleep(300);
    }
  }
  throw new Error('timeout');
}

let paused = false;
document.addEventListener('visibilitychange', () => {
  paused = document.hidden;
});
// 轮询循环里：while (paused) await sleep(500);

本机 curl 上游：200
Worker 调上游：429 / 403，稳定复现
换一把 Key：还是 429

宿主页面 ──script──▶ Worker ──▶ VPS / 云函数（独立 IP）──▶ 上游

relay2.mydomain.com {
    @bad not header X-Relay-Token "你的随机长串"
    respond @bad 403

    reverse_proxy https://api.example.com {
        header_up Host api.example.com
        flush_interval -1
    }
}

const up = await fetch('https://relay2.mydomain.com/v1/chat', {
  method: 'POST',
  headers: {
    'content-type': 'application/json',
    'x-relay-token': this.env.RELAY_TOKEN,
  },
  body,
});

const REF_OK = ['app.builda.game', 'game.builda.game'];
const ref = req.headers.get('referer') || '';
let host = '';
try { host = ref ? new URL(ref).host : ''; } catch (e) {}

if (!REF_OK.includes(host)) {
  return cb ? js(cb, { ok: false, err: 'forbidden' }) : new Response('forbidden', { status: 403 });
}

// 签发（你的服务端）
const tk = crypto.randomUUID();
await KV.put('tk:' + tk, uid, { expirationTtl: 300 });   // 5 分钟有效

// 校验（Worker）
const uid = await env.KV.get('tk:' + tk);
if (!uid) return forbidden();
await env.KV.delete('tk:' + tk);   // 用一次就废

const BUCKET = new Map();   // key → { tokens, at }
const RATE = 20 / 60000;    // 每毫秒补多少（20 次/分钟）
const CAP = 20;

function allow(key) {
  const now = Date.now();
  let b = BUCKET.get(key);
  if (!b) b = { tokens: CAP, at: now };

  b.tokens = Math.min(CAP, b.tokens + (now - b.at) * RATE);
  b.at = now;

  if (b.tokens < 1) { BUCKET.set(key, b); return false; }
  b.tokens -= 1;
  BUCKET.set(key, b);
  return true;
}

const ALLOW_MODEL = new Set(['model-a', 'model-b']);
if (body.model && !ALLOW_MODEL.has(body.model)) return bad('model');

// URL 里能传的只有这些，其余一律忽略
const q = (u.searchParams.get('q') || '').slice(0, 2000);

// ❌ 只防了第一段
const r = await fetch(url, { signal: AbortSignal.timeout(12000) });

// ✅ 读流再加一道
const it = await Promise.race([
  reader.read(),
  new Promise((_, rej) => setTimeout(() => rej(new Error('idle')), 20000)),
]);

location.origin   // "https://mygame.com"

curl -i https://mygame.com/api/__probe
# 返回你自己的东西 → 能挂；返回平台 404 页 → 不能

server {
    listen 443 ssl http2;
    server_name mygame.com;

    root /var/www/game;
    index index.html;

    location /api/ {
        proxy_pass https://api.example.com/;

        proxy_ssl_server_name on;
        proxy_set_header Host api.example.com;
        proxy_set_header Authorization "Bearer sk-你的密钥";

        # 流式三件套
        proxy_buffering off;
        proxy_cache off;
        proxy_http_version 1.1;
        proxy_set_header Connection "";

        proxy_read_timeout 300s;
        proxy_send_timeout 300s;
    }
}

mygame.com {
    root * /var/www/game
    file_server

    handle_path /api/* {
        reverse_proxy https://api.example.com {
            header_up Host api.example.com
            header_up Authorization "Bearer sk-你的密钥"
            flush_interval -1
        }
    }
}

宿主页面（connect-src / script-src 都锁）
   │ postMessage
   ▼
你的桥页面 https://bridge.mydomain.com（CSP 你自己定，宽松）
   │ fetch
   ▼
外部 API

const waits = new Map();
let seq = 0;

addEventListener('message', (e) => {
  if (e.origin !== 'https://bridge.mydomain.com') return;   // 必须校验
  const { id, ok, data, err } = e.data || {};
  const w = waits.get(id);
  if (!w) return;
  waits.delete(id);
  ok ? w.resolve(data) : w.reject(new Error(err));
});

function viaBridge(payload) {
  return new Promise((resolve, reject) => {
    const id = ++seq;
    waits.set(id, { resolve, reject });
    frame.contentWindow.postMessage({ id, payload }, 'https://bridge.mydomain.com');
    setTimeout(() => { if (waits.delete(id)) reject(new Error('timeout')); }, 30000);
  });
}

<script>
const ALLOW = ['https://app.builda.game'];
addEventListener('message', async (e) => {
  if (!ALLOW.includes(e.origin)) return;
  const { id, payload } = e.data;
  try {
    const r = await fetch('https://api.example.com/v1/chat', {
      method: 'POST',
      headers: { 'content-type': 'application/json' },
      body: JSON.stringify(payload),
    });
    parent.postMessage({ id, ok: r.ok, data: await r.text() }, e.origin);
  } catch (err) {
    parent.postMessage({ id, ok: false, err: String(err) }, e.origin);
  }
});
</script>

# 我在哪个源
location.origin

# 宿主到底锁了什么
curl -sI https://app.builda.game | grep -i content-security-policy

# 我的接应点通不通
curl -s "https://relay.mydomain.com/q?q=hi&cb=t"   # 应返回 t({...})

页面源归你        → 同源反代（最优）
页面源不归你
  ├ script-src 放行 → JSONP + 长轮询（宿主场景唯一解）
  ├ 只放 frame-src  → iframe 桥
  └ 都锁            → 找宿主加白名单
出口 IP 被限       → 加一跳 VPS / 云函数