MCP 速率限制

async function callWithRetry(fn, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (err) {
      if (err.status === 429 && i < maxRetries - 1) {
        const delay = Math.pow(2, i) * 1000; // 1s, 2s, 4s
        await new Promise((r) => setTimeout(r, delay));
      } else {
        throw err;
      }
    }
  }
}

async function callWithRetry<T>(
  fn: () => Promise<T>,
  maxRetries = 3
): Promise<T> {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (err) {
      const status = (err as { status?: number }).status;
      if (status === 429 && i < maxRetries - 1) {
        const delay = Math.pow(2, i) * 1000; // 1s, 2s, 4s
        await new Promise((r) => setTimeout(r, delay));
      } else {
        throw err;
      }
    }
  }
  throw new Error("unreachable");
}

import asyncio
from typing import Awaitable, Callable, TypeVar

T = TypeVar("T")


async def call_with_retry(
    fn: Callable[[], Awaitable[T]],
    max_retries: int = 3,
) -> T:
    for i in range(max_retries):
        try:
            return await fn()
        except Exception as err:
            status = getattr(err, "status", None) or getattr(err, "status_code", None)
            if status == 429 and i < max_retries - 1:
                await asyncio.sleep(2**i)  # 1s, 2s, 4s
            else:
                raise
    raise RuntimeError("unreachable")

import (
	"errors"
	"time"
)

var ErrRateLimited = errors.New("rate limited")

func callWithRetry(fn func() error, maxRetries int) error {
	if maxRetries <= 0 {
		maxRetries = 3
	}
	for i := 0; i < maxRetries; i++ {
		err := fn()
		if err == nil {
			return nil
		}
		if errors.Is(err, ErrRateLimited) && i < maxRetries-1 {
			time.Sleep(time.Duration(1<<uint(i)) * time.Second) // 1s, 2s, 4s
			continue
		}
		return err
	}
	return nil
}

import java.util.concurrent.Callable;

public static <T> T callWithRetry(Callable<T> fn, int maxRetries) throws Exception {
  if (maxRetries <= 0) {
    maxRetries = 3;
  }
  for (int i = 0; i < maxRetries; i++) {
    try {
      return fn.call();
    } catch (RateLimitException e) {
      if (e.getStatus() == 429 && i < maxRetries - 1) {
        Thread.sleep((long) Math.pow(2, i) * 1000); // 1s, 2s, 4s
      } else {
        throw e;
      }
    }
  }
  throw new IllegalStateException("unreachable");
}