git clone https://github.com/knapcio/GLM-5.3-4x-DGX-Spark-TP4 && cd GLM-5.3-4x-DGX-Spark-TP4
cp .env.example .env            # 填写 4 个主机、单条 rail 的地址、镜像 ID、路径、NCCL hash
bash overlay/guard/build_guard.sh
./start.sh l2hint-setup && ./start.sh attnfront-setup
DRY=1 ./start.sh serve && ./start.sh preflight && ./start.sh serve
curl http://GX10-1:8000/v1/models   # 验证 OpenAI 兼容接口

cd tinydc && python3 -m venv .venv && . .venv/bin/activate
pip install -r requirements.txt
export ROUTER_CLIENT_KEY=sk-tyum-xxx ANTHROPIC_API_KEY=... OPENAI_API_KEY=... \
       DASHSCOPE_API_KEY=... ZAI_API_KEY=...
uvicorn ai_router:app --host 0.0.0.0 --port 8080

# Claude Code
export ANTHROPIC_BASE_URL=http://router:8080
export ANTHROPIC_AUTH_TOKEN=sk-tyum-xxx

# OpenAI 兼容客户端（Codex、Cline、SDK）
export OPENAI_BASE_URL=http://router:8080/v1
export OPENAI_API_KEY=sk-tyum-xxx

# 强制走某个级别
curl http://router:8080/v1/chat/completions -H "x-route-tier: plan" ...
# 查看用量
curl http://router:8080/stats -H "x-api-key: sk-tyum-xxx"

# AI-Router 配置示例。密钥通过环境变量注入，切勿写入文件。
listen: {host: 0.0.0.0, port: 8080}
client_keys: [${ROUTER_CLIENT_KEY}]       # 客户端访问路由器所用的 Key
db: ./usage.sqlite

backends:
  local-glm:                               # 4x GX10 TP4, vLLM
    openai_url:    http://10.10.0.10:8000/v1
    anthropic_url: http://10.10.0.10:8000      # vLLM /v1/messages
    key: EMPTY
    model: glm-5.3
    max_inflight: 4                        # 4 个服务槽位，超出即溢出
    max_context: 200000
    price: {in: 0, out: 0}
  claude:
    anthropic_url: https://api.anthropic.com
    key: ${ANTHROPIC_API_KEY}
    model: claude-opus-4-5
    price: {in: 15, out: 75}               # USD / 1M tokens
  claude-fast:
    anthropic_url: https://api.anthropic.com
    key: ${ANTHROPIC_API_KEY}
    model: claude-sonnet-4-5
    price: {in: 3, out: 15}
  openai:
    openai_url: https://api.openai.com/v1
    key: ${OPENAI_API_KEY}
    model: gpt-5
    price: {in: 1.25, out: 10}
  qwen:
    openai_url: https://dashscope.aliyuncs.com/compatible-mode/v1
    anthropic_url: https://dashscope.aliyuncs.com/apps/anthropic
    key: ${DASHSCOPE_API_KEY}
    model: qwen3-coder-plus
    price: {in: 1, out: 5}
  glm-cloud:
    openai_url: https://open.bigmodel.cn/api/paas/v4
    anthropic_url: https://open.bigmodel.cn/api/anthropic
    key: ${ZAI_API_KEY}
    model: glm-5.3
    price: {in: 0.6, out: 2.2}

# 分级：按顺序尝试，首个可用（健康且未过载）者胜出；其余为故障转移
tiers:
  private: [local-glm]                     # 含敏感标记，只允许本地
  simple:  [local-glm, qwen, glm-cloud]
  code:    [local-glm, qwen, glm-cloud, claude-fast]
  complex: [claude, openai, glm-cloud]
  plan:    [claude, openai]                # 计划/架构/评审类
  longctx: [claude-fast, qwen]             # 超出本地上下文

rules:
  private_markers: ["#private", "CONFIDENTIAL", "机密", "内部资料"]
  plan_keywords:   ["plan", "architecture", "design doc", "roadmap", "方案", "规划", "架构", "评审", "拆解"]
  complex_keywords: ["refactor", "root cause", "prove", "migrate", "重构", "根因", "复杂", "多文件"]
  code_markers:    ["```", "def ", "class ", "function", "traceback", "代码", "报错"]
  simple_max_tokens: 1500       # 估算输入 token 低于此值且无特征 → simple
  complex_min_tokens: 24000     # 大上下文倾向云端
  tools_min_for_complex: 12     # 工具/消息轮次很多的 agent 会话视为 complex
  header_override: x-route-tier # 客户端可强制指定 tier
  daily_budget_usd: 50          # 云端日预算；超出后降级到 local/qwen/glm

#!/usr/bin/env python3
"""AI-Router 多模型聚合词元光控平台（TinyDC Token-FREE）: 按任务复杂度/成本/隐私在本地GLM与Claude/OpenAI/Qwen/GLM云之间路由。

入口(与官方 SDK 兼容):
  POST /v1/chat/completions   (OpenAI 协议)   -> 供 Codex/OpenAI SDK/Cline 等
  POST /v1/messages           (Anthropic 协议) -> 供 Claude Code (ANTHROPIC_BASE_URL)
  GET  /healthz  /stats
依赖: pip install fastapi uvicorn httpx pyyaml
运行: uvicorn ai_router:app --host 0.0.0.0 --port 8080
"""
import asyncio, json, os, re, sqlite3, time
from datetime import date
import httpx, yaml
from fastapi import FastAPI, Request, HTTPException
from fastapi.responses import JSONResponse, StreamingResponse

CFG_PATH = os.environ.get("AIROUTER_CONFIG", "config.yaml")

def load_cfg():
    raw = open(CFG_PATH, encoding="utf-8").read()
    raw = re.sub(r"\$\{(\w+)\}", lambda m: os.environ.get(m.group(1), ""), raw)
    return yaml.safe_load(raw)

CFG = load_cfg()
R = CFG["rules"]
BE = CFG["backends"]
inflight = {k: 0 for k in BE}
down_until = {k: 0.0 for k in BE}          # 熔断：失败后暂时摘除
client = httpx.AsyncClient(timeout=httpx.Timeout(600, connect=10))
db = sqlite3.connect(CFG.get("db", "usage.sqlite"), check_same_thread=False)
db.execute("""create table if not exists usage(ts real, day text, backend text, tier text,
  proto text, tin int, tout int, cost real, ms int, status int)""")
app = FastAPI(title="AI-Router")

# ---------------- 分类 ----------------
def text_of(body: dict) -> str:
    parts = []
    sysm = body.get("system")
    if isinstance(sysm, str): parts.append(sysm)
    elif isinstance(sysm, list): parts += [b.get("text", "") for b in sysm if isinstance(b, dict)]
    for m in body.get("messages", []):
        c = m.get("content")
        if isinstance(c, str): parts.append(c)
        elif isinstance(c, list):
            for b in c:
                if isinstance(b, dict):
                    parts.append(b.get("text") or json.dumps(b.get("input", ""), ensure_ascii=False)
                                 if b.get("type") != "tool_result" else str(b.get("content", ""))[:2000])
    return "\n".join(p for p in parts if p)

def est_tokens(s: str) -> int:     # 粗估：CJK 约 1 字/token，其余约 4 字符/token
    cjk = len(re.findall(r"[\u4e00-\u9fff]", s))
    return cjk + (len(s) - cjk) // 4

def last_user(body: dict) -> str:
    for m in reversed(body.get("messages", [])):
        if m.get("role") == "user":
            c = m.get("content")
            if isinstance(c, str): return c
            if isinstance(c, list):
                return " ".join(b.get("text", "") for b in c if isinstance(b, dict) and b.get("type") == "text")
    return ""

def classify(body: dict, hdr_tier: str | None):
    full, last = text_of(body), last_user(body)
    n = est_tokens(full)
    if hdr_tier in CFG["tiers"]: return hdr_tier, n, "header"
    if any(k.lower() in full.lower() for k in R["private_markers"]): return "private", n, "private-marker"
    # Claude Code 的 plan 模式会在系统提示中带 "plan mode"
    if re.search(r"plan mode|plan_mode|ExitPlanMode", full[:20000], re.I): return "plan", n, "plan-mode"
    ll = last.lower()
    if any(k.lower() in ll for k in R["plan_keywords"]): return "plan", n, "plan-keyword"
    if n > R["complex_min_tokens"]: return "longctx", n, "long-context"
    turns = len(body.get("messages", []))
    if any(k.lower() in ll for k in R["complex_keywords"]) or turns >= R["tools_min_for_complex"] \
       or len(body.get("tools", []) or []) > 0 and any(k in ll for k in ("多文件", "multi-file", "整个项目")):
        return "complex", n, "complex-keyword/turns"
    if any(k.lower() in full.lower() for k in R["code_markers"]): return "code", n, "code-marker"
    if n < R["simple_max_tokens"]: return "simple", n, "short"
    return "code", n, "default"

# ---------------- 选择后端 ----------------
def spent_today() -> float:
    r = db.execute("select coalesce(sum(cost),0) from usage where day=?", (str(date.today()),)).fetchone()
    return r[0]

def candidates(tier: str, proto: str, n: int):
    over = spent_today() >= R.get("daily_budget_usd", 1e9)
    out = []
    for name in CFG["tiers"][tier]:
        b = BE[name]
        if f"{proto}_url" not in b or time.time() < down_until[name]: continue
        if b.get("max_context", 10**9) < n + 4096: continue
        if inflight[name] >= b.get("max_inflight", 10**9): continue          # 本地过载 → 溢出
        paid = b["price"]["out"] > 0
        if over and paid and tier != "private": continue                      # 预算耗尽
        out.append(name)
    if not out and tier != "private":                                         # 兜底：任何协议匹配者
        out = [k for k, b in BE.items() if f"{proto}_url" in b and time.time() >= down_until[k]]
    return out

def headers_for(b, proto, req_headers):
    if proto == "anthropic":
        h = {"x-api-key": b["key"], "anthropic-version": req_headers.get("anthropic-version", "2023-06-01"),
             "content-type": "application/json"}
        if "anthropic-beta" in req_headers: h["anthropic-beta"] = req_headers["anthropic-beta"]
        return h
    return {"authorization": f"Bearer {b['key']}", "content-type": "application/json"}

def log(name, tier, proto, tin, tout, t0, status):
    p = BE[name]["price"]
    cost = (tin * p["in"] + tout * p["out"]) / 1e6
    db.execute("insert into usage values(?,?,?,?,?,?,?,?,?,?)",
               (time.time(), str(date.today()), name, tier, proto, tin, tout, cost, int((time.time()-t0)*1000), status))
    db.commit()

def usage_from(obj: dict):
    u = obj.get("usage") or {}
    return (u.get("input_tokens") or u.get("prompt_tokens") or 0,
            u.get("output_tokens") or u.get("completion_tokens") or 0)

# ---------------- 转发 ----------------
async def forward(request: Request, proto: str, path: str):
    auth = request.headers.get("x-api-key") or request.headers.get("authorization", "").removeprefix("Bearer ")
    if CFG.get("client_keys") and auth not in CFG["client_keys"]:
        raise HTTPException(401, "bad router key")
    body = await request.json()
    tier, n, why = classify(body, request.headers.get(R.get("header_override", "x-route-tier")))
    names = candidates(tier, proto, n)
    if not names: raise HTTPException(503, f"no backend for tier={tier} proto={proto}")
    stream = bool(body.get("stream"))
    last_err = None
    for name in names:                                                         # 故障转移
        b = BE[name]
        payload = dict(body); payload["model"] = b["model"]
        if proto == "openai" and stream:
            payload.setdefault("stream_options", {"include_usage": True})
        url = b[f"{proto}_url"].rstrip("/") + path
        hd = headers_for(b, proto, request.headers)
        rh = {"x-router-backend": name, "x-router-tier": tier, "x-router-reason": why}
        t0 = time.time(); inflight[name] += 1
        try:
            if not stream:
                r = await client.post(url, json=payload, headers=hd)
                inflight[name] -= 1
                if r.status_code >= 500 or r.status_code == 429:
                    down_until[name] = time.time() + (5 if r.status_code == 429 else 30)
                    last_err = r.status_code; continue
                try: tin, tout = usage_from(r.json())
                except Exception: tin = tout = 0
                log(name, tier, proto, tin or n, tout, t0, r.status_code)
                return JSONResponse(r.json(), status_code=r.status_code, headers=rh)
            req = client.build_request("POST", url, json=payload, headers=hd)
            r = await client.send(req, stream=True)
            if r.status_code >= 500 or r.status_code == 429:
                await r.aclose(); inflight[name] -= 1
                down_until[name] = time.time() + (5 if r.status_code == 429 else 30)
                last_err = r.status_code; continue

            async def gen(r=r, name=name, t0=t0):
                tin = tout = 0
                try:
                    async for line in r.aiter_lines():
                        if line.startswith("data:") and "usage" in line:
                            try:
                                a, o = usage_from(json.loads(line[5:]))
                                d = json.loads(line[5:]); 
                                a2, o2 = usage_from(d.get("message", {})) if "message" in d else (0, 0)
                                tin = max(tin, a, a2); tout = max(tout, o, o2)
                            except Exception: pass
                        yield line + "\n"
                finally:
                    await r.aclose(); inflight[name] -= 1
                    log(name, tier, proto, tin or n, tout, t0, r.status_code)
            return StreamingResponse(gen(), status_code=r.status_code,
                                     media_type="text/event-stream", headers=rh)
        except (httpx.ConnectError, httpx.ReadTimeout, httpx.RemoteProtocolError) as e:
            inflight[name] = max(0, inflight[name] - 1)
            down_until[name] = time.time() + 30; last_err = str(e)
    raise HTTPException(502, f"all backends failed: {last_err}")

@app.post("/v1/chat/completions")
async def chat(request: Request): return await forward(request, "openai", "/chat/completions")

@app.post("/v1/messages")
async def messages(request: Request): return await forward(request, "anthropic", "/v1/messages")

@app.post("/v1/messages/count_tokens")
async def count(request: Request):
    body = await request.json()
    return {"input_tokens": est_tokens(text_of(body))}

@app.get("/healthz")
async def health():
    return {k: {"inflight": inflight[k], "down": max(0, int(down_until[k]-time.time()))} for k in BE}

@app.get("/stats")
async def stats():
    rows = db.execute("select day,backend,tier,count(*),sum(tin),sum(tout),round(sum(cost),4) "
                      "from usage group by 1,2,3 order by 1 desc limit 200").fetchall()
    return {"spent_today_usd": spent_today(),
            "rows": [dict(zip("day backend tier n tin tout usd".split(), r)) for r in rows]}