「同じ 429」が経路ごとに違う顔で返る — Claude を Anthropic 直叩きと Azure Foundry の二経路で安全に回す

# Before: 直叩きの形だけを前提にしたリトライ
import time
 
def call_with_retry_naive(client, **kwargs):
    for attempt in range(5):
        resp = client.post("/v1/messages", json=kwargs)
        if resp.status_code == 200:
            return resp.json()
        if resp.status_code == 429:
            # 落とし穴1: retry-after を「必ず整数秒」と決め打ち
            wait = int(resp.headers.get("retry-after", 1))
            time.sleep(wait)
            continue
        # 落とし穴2: 529/503 や本文の差を見ず、すべて即例外に
        resp.raise_for_status()
    raise RuntimeError("exhausted")

from dataclasses import dataclass
from enum import Enum
from typing import Optional
 
class ErrorCategory(Enum):
    OK = "ok"
    RATE_LIMIT = "rate_limit"   # 429
    OVERLOADED = "overloaded"   # 529 / 503
    AUTH = "auth"               # 401 / 403
    BAD_REQUEST = "bad_request" # 400 / 404 / 422
    SERVER = "server"           # 500 系
 
@dataclass
class NormalizedError:
    route: str                          # "anthropic" / "azure"
    status: int
    category: ErrorCategory
    retryable: bool                     # 同じ経路で待って再試行してよいか
    failover_worthy: bool               # もう一方の経路へ逃がす価値があるか
    retry_after_s: Optional[float]      # 経路差を吸収した「秒」
    raw_code: Optional[str] = None      # 監査用に元の鍵を残す

from email.utils import parsedate_to_datetime
from datetime import datetime, timezone
 
def parse_retry_after(value: Optional[str]) -> Optional[float]:
    if not value:
        return None
    value = value.strip()
    # 形式1: 整数秒（Anthropic 直叩き / Azure の一部）
    if value.isdigit():
        return float(value)
    # 形式2: HTTP-date（Azure で混在）
    try:
        dt = parsedate_to_datetime(value)
        if dt.tzinfo is None:
            dt = dt.replace(tzinfo=timezone.utc)
        delta = (dt - datetime.now(timezone.utc)).total_seconds()
        return max(0.0, delta)   # 過去日付なら 0 に丸める
    except (TypeError, ValueError):
        return None              # 不明な形式は上位のバックオフに任せる

def resolve_anthropic(status: int, headers: dict, body: dict) -> NormalizedError:
    ra = parse_retry_after(headers.get("retry-after"))
    etype = (body.get("error") or {}).get("type")
    if status == 429:
        cat, retryable, fo = ErrorCategory.RATE_LIMIT, True, True
    elif status == 529:
        cat, retryable, fo = ErrorCategory.OVERLOADED, True, True
    elif status in (401, 403):
        cat, retryable, fo = ErrorCategory.AUTH, False, False
    elif 400 <= status < 500:
        cat, retryable, fo = ErrorCategory.BAD_REQUEST, False, False
    elif status >= 500:
        cat, retryable, fo = ErrorCategory.SERVER, True, True
    else:
        cat, retryable, fo = ErrorCategory.OK, False, False
    return NormalizedError("anthropic", status, cat, retryable, fo, ra, etype)
 
def resolve_azure(status: int, headers: dict, body: dict) -> NormalizedError:
    ra = parse_retry_after(headers.get("Retry-After"))
    code = str((body.get("error") or {}).get("code", ""))
    if status == 429:
        cat, retryable, fo = ErrorCategory.RATE_LIMIT, True, True
    elif status == 503:
        cat, retryable, fo = ErrorCategory.OVERLOADED, True, True
    elif status in (401, 403):
        cat, retryable, fo = ErrorCategory.AUTH, False, False
    elif 400 <= status < 500:
        cat, retryable, fo = ErrorCategory.BAD_REQUEST, False, False
    elif status >= 500:
        cat, retryable, fo = ErrorCategory.SERVER, True, True
    else:
        cat, retryable, fo = ErrorCategory.OK, False, False
    return NormalizedError("azure", status, cat, retryable, fo, ra, code)

import random, time
 
def backoff_seconds(attempt: int, retry_after: Optional[float]) -> float:
    # retry_after があれば最優先。なければ指数 + フルジッター、上限 30 秒
    if retry_after is not None:
        return min(retry_after, 30.0)
    base = min(2 ** attempt, 30.0)
    return random.uniform(0, base)   # thundering herd 回避のフルジッター
 
def call_dual_route(routes, payload, max_attempts_per_route=4):
    # routes: [(name, send_fn, resolver), ...]  例: [direct, azure]
    last_err = None
    for name, send_fn, resolver in routes:
        for attempt in range(max_attempts_per_route):
            status, headers, body = send_fn(payload)
            if status == 200:
                return body
            err = resolver(status, headers, body)
            last_err = err
            if not err.retryable:
                if err.failover_worthy:
                    break            # この経路は見切り、次の経路へ
                raise ApiError(err)  # 400/401 は両経路で同じ。即失敗
            wait = backoff_seconds(attempt, err.retry_after_s)
            time.sleep(wait)
        # この経路で max_attempts を使い切った → 次の経路へ failover
    raise ApiError(last_err)
 
class ApiError(Exception):
    def __init__(self, err: NormalizedError):
        self.err = err
        super().__init__(f"{err.route} {err.status} {err.category.value}")