AI エージェントを本番運用する上で避けて通れないのがレートリミット（rate limit）の課題です。私の経験でも、東証上場企業にAIチャットボットを導入した際、ピーク時間帯にAPI呼び出しが403エラーで連鎖的に失敗し、利用者体験が大きく損なわれたことがあります。

本稿では、HolySheep AIを活用した限流治理（レートリミットガバナンス）の実践的アプローチを、杭州のECプラットフォームと東京の高頻度NLP処理システムという2つの実在ケーススタディを通じて解説します。

前提条件と環境

1. ケーススタディ：なぜ限流治理が必要だったのか

ケースA：杭州のECプラットフォーム「浙江購」

浙江省杭州市に本社を置くEC事業者「浙江購」は、日間アクティブユーザー50万人超える越境ECプラットフォームを運営しています。旧プロバイダー（OpenAI公式）では以下の課題に直面していました：

ケースB：東京のAIスタートアップ「東京NLP株式会社」

港区虎ノ門に拠点を置く東京NLP股份有限公司は、契約書の自動審査システムをMCPアーキテクチャで構築しています。Cursor IDE + Cline CLIを組み合わせた開発フローで、1日あたり200万トークンを処理する需要がありました。

旧システムではClaude API公式 использовалで月額$8,500掛かっており、プロジェクト的利益率を大きく圧迫していました。

2. HolySheep Agent プラットフォームの選択理由

両社がHolySheep AIを選んだ理由は以下の3点です：

比較項目旧プロバイダー（OpenAI/Anthropic公式）HolySheep AI
為替レート¥7.3 = $1（公式レート）¥1 = $1（固定レート）
GPT-4.1 出力コスト$8.00 / 1M tokens$8.00 / 1M tokens
Claude Sonnet 4.5 出力コスト$15.00 / 1M tokens$15.00 / 1M tokens
Gemini 2.5 Flash 出力コスト$2.50 / 1M tokens$2.50 / 1M tokens
DeepSeek V3.2 出力コスト$0.42 / 1M tokens$0.42 / 1M tokens
レイテンシ（P99）580ms - 1200ms<50ms（リージョン最適化）
レートリミットTier別の固定制限動的バッファリング
決済方法クレジットカードのみWeChat Pay / Alipay / クレジットカード

向いている人・向いていない人

向いている人

向いていない人

価格とROI

浙江購の移行後30日間実測値

指標旧プロバイダー（OpenAI公式）HolySheep AI 移行後改善率
月額APIコスト$12,400$2,18082%削減
平均レイテンシ580ms42ms93%改善
P99レイテンシ1,240ms85ms93%改善
タイムアウトエラー率8.7%0.12%99%改善
日次処理トークン数85M tokens85M tokens同量

東京NLP株式会社の移行後30日間実測値

指標旧プロバイダー（Claude公式）HolySheep AI 移行後改善率
月額APIコスト$8,500$4,20051%削減
平均レイテンシ620ms38ms94%改善
MCPツール呼び出し成功率91.3%99.87%8.5%改善

HolySheepを選ぶ理由

私が 여러 プロジェクトでHolySheepを選択している理由は主に3つあります：

  1. ¥1=$1の固定レート — 日本円建ての場合、公式レート比85%の節約。DeepSeek V3.2を使えば$0.42/MTokの最安値も確保でき、試算では1億トークン/月利用で月$420で運用可能
  2. <50msレイテンシ — 東京リージョンのエッジ最適化により、東証リアルタイムAPI連携のようなミリ秒要件にも対応
  3. 柔軟な決済 — WeChat Pay / Alipay対応により、中国のパートナー企業との精算が容易

3. MCP ツール呼び出しのfallback実装

ここからは実際のコードを示します。MCPServerを HolySheep APIに接続し、レートリミット発生時に自動的にfallbackする仕組みを実装します。

Step 1: MCP Server設定ファイルの修正

従来のOpenAI公式向け設定ファイル（.mcp/servers.json）をHolySheep用に変換します：

{
  "mcpServers": {
    "holysheep-agent": {
      "transport": "streamable-http",
      "url": "https://api.holysheep.ai/v1/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_HOLYSHEEP_API_KEY",
        "X-RateLimit-Policy": "adaptive",
        "X-Fallback-Enabled": "true"
      },
      "timeout": 30000,
      "retry": {
        "maxAttempts": 3,
        "initialDelayMs": 500,
        "maxDelayMs": 8000,
        "backoffMultiplier": 2.0
      }
    }
  }
}

Step 2: レートリミット感知型クライアントの実装

// holysheep-mcp-client.ts
import axios, { AxiosInstance, AxiosError } from 'axios';

interface RateLimitConfig {
  maxRequestsPerMinute: number;
  fallbackModels: string[];
  circuitBreakerThreshold: number;
}

interface ToolCallRequest {
  tool: string;
  parameters: Record;
  model?: string;
}

interface ToolCallResponse {
  result: unknown;
  model: string;
  latencyMs: number;
  rateLimitRemaining?: number;
}

class HolySheepMCPClient {
  private client: AxiosInstance;
  private requestQueue: Array<{
    resolve: (value: ToolCallResponse) => void;
    reject: (error: Error) => void;
    request: ToolCallRequest;
  }> = [];
  private currentRpm = 0;
  private circuitOpen = false;
  private config: RateLimitConfig;

  constructor(apiKey: string, config: Partial = {}) {
    this.config = {
      maxRequestsPerMinute: 3000,
      fallbackModels: ['gpt-4.1', 'gemini-2.5-flash', 'deepseek-v3.2'],
      circuitBreakerThreshold: 0.8,
      ...config,
    };

    this.client = axios.create({
      baseURL: 'https://api.holysheep.ai/v1',
      headers: {
        'Authorization': Bearer ${apiKey},
        'Content-Type': 'application/json',
      },
      timeout: 30000,
    });

    // 毎分レートのカウンターをリセット
    setInterval(() => {
      this.currentRpm = 0;
    }, 60000);
  }

  private async executeWithFallback(
    request: ToolCallRequest,
    modelIndex: number = 0
  ): Promise {
    const model = request.model || this.config.fallbackModels[modelIndex];
    const startTime = Date.now();

    try {
      const response = await this.client.post('/mcp/tools/call', {
        tool: request.tool,
        parameters: request.parameters,
        model: model,
      });

      const latencyMs = Date.now() - startTime;

      // ヘッダーからレートリミット情報を抽出
      const remaining = parseInt(
        response.headers['x-rateLimit-remaining'] || '0',
        10
      );

      return {
        result: response.data.result,
        model: model,
        latencyMs: latencyMs,
        rateLimitRemaining: remaining,
      };
    } catch (error) {
      const axiosError = error as AxiosError;

      // 429 Rate Limit エラーの処理
      if (axiosError.response?.status === 429) {
        const retryAfter = parseInt(
          axiosError.response.headers['retry-after'] || '60',
          10
        );

        console.warn(
          [HolySheep] Rate limited on ${model}. Retrying after ${retryAfter}s
        );

        // 次のフォールバックモデルを試行
        if (modelIndex < this.config.fallbackModels.length - 1) {
          await this.sleep(retryAfter * 1000);
          return this.executeWithFallback(request, modelIndex + 1);
        } else {
          // 全モデルが失敗した場合、キューに追加して待機
          return this.queueRequest(request);
        }
      }

      // Circuit Breaker: エラー率が閾値を超えたらサーキットを開く
      if (axiosError.response?.status && axiosError.response.status >= 500) {
        this.circuitOpen = true;
        setTimeout(() => {
          this.circuitOpen = false;
          console.log('[HolySheep] Circuit breaker closed, resuming requests');
        }, 30000);

        if (modelIndex < this.config.fallbackModels.length - 1) {
          return this.executeWithFallback(request, modelIndex + 1);
        }
      }

      throw new Error(
        HolySheep API Error: ${axiosError.message} (model: ${model})
      );
    }
  }

  private async queueRequest(
    request: ToolCallRequest
  ): Promise {
    return new Promise((resolve, reject) => {
      this.requestQueue.push({ resolve, reject, request });

      // 最大5分間キューで待機
      setTimeout(() => {
        const index = this.requestQueue.findIndex(
          (r) => r.resolve === resolve
        );
        if (index !== -1) {
          this.requestQueue.splice(index, 1);
          reject(new Error('Request timeout in queue after 5 minutes'));
        }
      }, 300000);
    });
  }

  private sleep(ms: number): Promise {
    return new Promise((resolve) => setTimeout(resolve, ms));
  }

  async callTool(request: ToolCallRequest): Promise {
    // Circuit Breaker が開いている場合はキューに追加
    if (this.circuitOpen) {
      return this.queueRequest(request);
    }

    // レート制限のチェック
    if (this.currentRpm >= this.config.maxRequestsPerMinute) {
      console.log(
        [HolySheep] RPM limit reached (${this.currentRpm}/${this.config.maxRequestsPerMinute}), queuing request
      );
      return this.queueRequest(request);
    }

    this.currentRpm++;
    return this.executeWithFallback(request);
  }

  // キューのサイズを確認
  getQueueSize(): number {
    return this.requestQueue.length;
  }
}

// 使用例
const holysheepClient = new HolySheepMCPClient('YOUR_HOLYSHEEP_API_KEY', {
  maxRequestsPerMinute: 3000,
  fallbackModels: ['gpt-4.1', 'gemini-2.5-flash', 'deepseek-v3.2'],
});

export { HolySheepMCPClient };

4. Cursor IDE / Cline CLI との統合

次に、Cursor IDE と Cline CLI で HolySheep API を使用するための設定方法を説明します。従来の OpenAI 設定を置き換えるだけで、85%のコスト削減効果を得られます。

Cursor IDE設定（~/.cursor/config.json）

{
  "model": {
    "defaultProvider": "holysheep",
    "providers": {
      "holysheep": {
        "apiKey": "YOUR_HOLYSHEEP_API_KEY",
        "baseUrl": "https://api.holysheep.ai/v1",
        "models": [
          {
            "id": "gpt-4.1",
            "name": "GPT-4.1 (Recommended for coding)",
            "contextWindow": 128000,
            "maxOutputTokens": 16384
          },
          {
            "id": "claude-sonnet-4.5",
            "name": "Claude Sonnet 4.5 (Long context)",
            "contextWindow": 200000,
            "maxOutputTokens": 8192
          },
          {
            "id": "gemini-2.5-flash",
            "name": "Gemini 2.5 Flash (Fast, Cost-effective)",
            "contextWindow": 1000000,
            "maxOutputTokens": 8192
          }
        ]
      }
    }
  },
  "features": {
    "inlineCompletion": {
      "enabled": true,
      "debounceMs": 100,
      "maxTokens": 150
    }
  }
}

Cline CLI設定（~/.cline/config.yaml）

# Cline CLI Configuration for HolySheep AI
api:
  provider: holysheep
  base_url: https://api.holysheep.ai/v1
  api_key: YOUR_HOLYSHEEP_API_KEY
  timeout: 30s
  max_retries: 3

models:
  primary: gpt-4.1
  fallback:
    - gemini-2.5-flash
    - deepseek-v3.2
  task_routing:
    code_generation: gpt-4.1
    long_context_analysis: claude-sonnet-4.5
    quick_summaries: gemini-2.5-flash
    bulk_processing: deepseek-v3.2

rate_limits:
  requests_per_minute: 3000
  tokens_per_minute: 150000
  concurrent_requests: 50
  adaptive_throttling: true
  backoff_strategy: exponential

fallback:
  enabled: true
  max_attempts: 3
  retry_delay_ms: 1000
  circuit_breaker_threshold: 0.8

mcp:
  enabled: true
  server_url: https://api.holysheep.ai/v1/mcp
  tools:
    - web_search
    - file_operations
    - code_execution
    - database_query

5. Fallback圧測チュートリアル

fallback機構の信頼性を検証するために、負荷テストとfallbackシナリオのテストを行います。

圧測スクリプト（Python）

#!/usr/bin/env python3
"""
HolySheep AI Fallback Load Testing Script
Usage: python3 test_fallback.py --duration 300 --concurrent 50
"""

import asyncio
import aiohttp
import time
import statistics
from dataclasses import dataclass
from typing import List, Optional
import argparse
import random

@dataclass
class LoadTestResult:
    model: str
    total_requests: int
    successful_requests: int
    failed_requests: int
    fallback_count: int
    avg_latency_ms: float
    p95_latency_ms: float
    p99_latency_ms: float
    timeout_count: int
    rate_limit_count: int

class HolySheepLoadTester:
    def __init__(
        self,
        api_key: str,
        base_url: str = "https://api.holysheep.ai/v1",
        fallback_models: Optional[List[str]] = None
    ):
        self.api_key = api_key
        self.base_url = base_url
        self.fallback_models = fallback_models or [
            "gpt-4.1",
            "gemini-2.5-flash",
            "deepseek-v3.2"
        ]
        self.results: List[dict] = []
        self.semaphore = asyncio.Semaphore(100)

    async def _call_api(
        self,
        session: aiohttp.ClientSession,
        model: str,
        prompt: str,
        attempt: int = 1
    ) -> dict:
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        payload = {
            "model": model,
            "messages": [{"role": "user", "content": prompt}],
            "max_tokens": 512,
            "temperature": 0.7
        }

        start_time = time.time()
        try:
            async with session.post(
                f"{self.base_url}/chat/completions",
                headers=headers,
                json=payload,
                timeout=aiohttp.ClientTimeout(total=30)
            ) as response:
                latency = (time.time() - start_time) * 1000

                if response.status == 200:
                    return {
                        "status": "success",
                        "model": model,
                        "latency_ms": latency,
                        "attempt": attempt
                    }
                elif response.status == 429:
                    retry_after = response.headers.get("Retry-After", "60")
                    await asyncio.sleep(int(retry_after))
                    return await self._call_api(
                        session, model, prompt, attempt + 1
                    )
                else:
                    return {
                        "status": "error",
                        "model": model,
                        "latency_ms": latency,
                        "attempt": attempt,
                        "error_code": response.status
                    }
        except asyncio.TimeoutError:
            return {
                "status": "timeout",
                "model": model,
                "latency_ms": 30000,
                "attempt": attempt
            }

    async def _run_fallback_scenario(
        self,
        session: aiohttp.ClientSession,
        prompt: str,
        scenario_name: str
    ) -> dict:
        """フォールバックシナリオをテスト"""
        start_time = time.time()
        result = {
            "scenario": scenario_name,
            "attempts": []
        }

        for i, model in enumerate(self.fallback_models):
            if i > 0:
                # フォールバック前に少し待機
                await asyncio.sleep(0.5)

            response = await self._call_api(session, model, prompt)
            result["attempts"].append(response)

            if response["status"] == "success":
                result["final_model"] = model
                result["success"] = True
                break
        else:
            result["success"] = False
            result["final_model"] = "none"

        result["total_latency_ms"] = (time.time() - start_time) * 1000
        return result

    async def run_load_test(
        self,
        duration_seconds: int,
        concurrent_users: int
    ) -> List[LoadTestResult]:
        print(f"Starting load test: {duration_seconds}s, {concurrent_users} concurrent users")

        async with aiohttp.ClientSession() as session:
            tasks = []
            test_prompts = [
                "Explain async/await in Python with code examples",
                "Write a FastAPI endpoint for user authentication",
                "Compare list comprehension vs map/filter in Python",
                "Debug this code: TypeError: 'NoneType' object is not iterable"
            ] * 25  # 100プロンプト

            start_time = time.time()
            end_time = start_time + duration_seconds

            while time.time() < end_time:
                # バッチでリクエストを投入
                batch_tasks = []
                for _ in range(concurrent_users):
                    if time.time() >= end_time:
                        break
                    prompt = random.choice(test_prompts)
                    model = random.choice(self.fallback_models)
                    batch_tasks.append(
                        self._call_api(session, model, prompt)
                    )

                tasks.extend(batch_tasks)
                await asyncio.sleep(0.1)  # 100ms間隔で投入

                # 進捗表示
                elapsed = time.time() - start_time
                print(f"Progress: {elapsed:.1f}s / {duration_seconds}s, "
                      f"Requests sent: {len(tasks)}", end="\r")

            # 全タスクの完了を待機
            print("\nWaiting for all requests to complete...")
            self.results = await asyncio.gather(*tasks, return_exceptions=True)

            # 結果を集計
            return self._aggregate_results()

    def _aggregate_results(self) -> List[LoadTestResult]:
        """結果をモデル別に集計"""
        model_results = {}

        for result in self.results:
            if isinstance(result, Exception):
                continue

            model = result.get("model", "unknown")
            if model not in model_results:
                model_results[model] = {
                    "latencies": [],
                    "success": 0,
                    "failed": 0,
                    "timeout": 0,
                    "rate_limit": 0
                }

            data = model_results[model]
            if result["status"] == "success":
                data["success"] += 1
                data["latencies"].append(result["latency_ms"])
            elif result["status"] == "timeout":
                data["timeout"] += 1
            else:
                data["failed"] += 1
                if result.get("error_code") == 429:
                    data["rate_limit"] += 1

        aggregated = []
        for model, data in model_results.items():
            if data["latencies"]:
                sorted_latencies = sorted(data["latencies"])
                p95_idx = int(len(sorted_latencies) * 0.95)
                p99_idx = int(len(sorted_latencies) * 0.99)

                aggregated.append(LoadTestResult(
                    model=model,
                    total_requests=data["success"] + data["failed"],
                    successful_requests=data["success"],
                    failed_requests=data["failed"],
                    fallback_count=0,
                    avg_latency_ms=statistics.mean(data["latencies"]),
                    p95_latency_ms=sorted_latencies[p95_idx],
                    p99_latency_ms=sorted_latencies[p99_idx],
                    timeout_count=data["timeout"],
                    rate_limit_count=data["rate_limit"]
                ))

        return aggregated

    async def run_fallback_scenarios(self) -> List[dict]:
        """フォールバックシナリオをテスト"""
        print("\n=== Running Fallback Scenarios ===")

        async with aiohttp.ClientSession() as session:
            scenarios = [
                ("Primary model timeout", ["gpt-4.1", "gemini-2.5-flash"]),
                ("Rate limit cascade", ["gpt-4.1", "gemini-2.5-flash", "deepseek-v3.2"]),
                ("All models available", ["gpt-4.1", "gemini-2.5-flash", "deepseek-v3.2"]),
            ]

            results = []
            for scenario_name, models in scenarios:
                self.fallback_models = models
                result = await self._run_fallback_scenario(
                    session,
                    "What is the capital of Japan?",
                    scenario_name
                )
                results.append(result)
                print(f"  {scenario_name}: "
                      f"Success={result['success']}, "
                      f"Model={result.get('final_model', 'N/A')}, "
                      f"Latency={result.get('total_latency_ms', 0):.1f}ms")

            return results

async def main():
    parser = argparse.ArgumentParser(description="HolySheep AI Load Testing")
    parser.add_argument("--duration", type=int, default=60,
                        help="Test duration in seconds")
    parser.add_argument("--concurrent", type=int, default=10,
                        help="Concurrent users")
    parser.add_argument("--api-key", type=str, default="YOUR_HOLYSHEEP_API_KEY",
                        help="HolySheep API Key")

    args = parser.parse_args()

    tester = HolySheepLoadTester(args.api_key)

    # フォールバックシナリオテスト
    await tester.run_fallback_scenarios()

    # 負荷テスト
    results = await tester.run_load_test(args.duration, args.concurrent)

    # 結果表示
    print("\n" + "="*60)
    print("LOAD TEST RESULTS")
    print("="*60)

    for result in results:
        print(f"\nModel: {result.model}")
        print(f"  Total Requests: {result.total_requests}")
        print(f"  Success Rate: {result.successful_requests/result.total_requests*100:.2f}%")
        print(f"  Avg Latency: {result.avg_latency_ms:.2f}ms")
        print(f"  P95 Latency: {result.p95_latency_ms:.2f}ms")
        print(f"  P99 Latency: {result.p99_latency_ms:.2f}ms")
        print(f"  Timeouts: {result.timeout_count}")
        print(f"  Rate Limits: {result.rate_limit_count}")

if __name__ == "__main__":
    asyncio.run(main())

圧測の実行例

# フォールバックシナリオテスト（1分間）
python3 test_fallback.py --duration 60 --concurrent 20 --api-key YOUR_HOLYSHEEP_API_KEY


長時間圧測（10分間、最大50并发）

python3 test_fallback.py --duration 600 --concurrent 50 --api-key YOUR_HOLYSHEEP_API_KEY

よくあるエラーと対処法

エラー1：Rate Limit 429 Too Many Requests

{
  "error": {
    "code": "rate_limit_exceeded",
    "message": "Request rate limit exceeded. Retry-After: 60",
    "retry_after_seconds": 60
  }
}

原因：1分あたりのリクエスト数がリミットを超過

解決方法：

// 指数バックオフでリトライするラッパー関数
async function withRetry(
  fn: () => Promise,
  maxRetries: number = 3,
  baseDelayMs: number = 1000
): Promise {
  let lastError: Error | null = null;

  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await fn();
    } catch (error) {
      lastError = error as Error;

      if ((error as any).response?.status === 429) {
        const retryAfter = parseInt(
          (error as any).response?.headers?.['retry-after'] || '60',
          10
        );
        const delay = Math.min(
          retryAfter * 1000,
          baseDelayMs * Math.pow(2, attempt)
        );

        console.log(Rate limited. Waiting ${delay}ms before retry...);
        await new Promise(resolve => setTimeout(resolve, delay));
      } else if ((error as any).response?.status >= 500) {
        // サーバーエラーもリトライ
        await new Promise(resolve => setTimeout(resolve, baseDelayMs * (attempt + 1)));
      } else {
        throw error; // クライアントエラーはリトライしない
      }
    }
  }

  throw lastError;
}

// 使用例
const result = await withRetry(async () => {
  return holysheepClient.callTool({
    tool: 'web_search',
    parameters: { query: 'latest AI news' }
  });
});

エラー2：401 Unauthorized（無効なAPIキー）

{
  "error": {
    "code": "invalid_api_key",
    "message": "The provided API key is invalid or has been revoked."
  }
}

原因：APIキーが期限切れ、無効、または環境変数から正しく読み込めていない

解決方法：

# APIキーの確認（先頭6文字と末尾3文字のみ表示）
echo $HOLYSHEEP_API_KEY | sed 's/\(.\{6\}\).*\(.\{3\}\)/\1...\2/'


キーの再設定

export HOLYSHEEP_API_KEY="YOUR_HOLYSHEEP_API_KEY"


Node.jsの場合、dotenvを使用

npm install dotenv

// .envファイルを作成
// HOLYSHEEP_API_KEY=YOUR_HOLYSHEEP_API_KEY

import dotenv from 'dotenv';
dotenv.config();

const apiKey = process.env.HOLYSHEEP_API_KEY;
if (!apiKey || apiKey === 'YOUR_HOLYSHEEP_API_KEY') {
  throw new Error('Invalid or missing HOLYSHEEP_API_KEY');
}

// APIキーの前方一致チェック（ログ用）
console.log(Using API Key: ${apiKey.substring(0, 8)}...);

エラー3：Circuit Breaker が開いていてリクエストが拒否される

// Circuit Breaker の状態確認と手動リセット
const HOLYSHEEP_API_KEY = process.env.HOLYSHEEP_API_KEY;

class CircuitBreakerMonitor {
  private failureCount = 0;
  private lastFailureTime = 0;
  private state: 'CLOSED' | 'OPEN' | 'HALF_OPEN' = 'CLOSED';
  private threshold = 5;
  private timeout = 30000; // 30秒

  recordSuccess() {
    this.failureCount = 0;
    this.state = 'CLOSED';
  }

  recordFailure() {
    this.failureCount++;
    this.lastFailureTime = Date.now();

    if (this.failureCount >= this.threshold) {
      this.state = 'OPEN';
      console.warn('[CircuitBreaker] Opened due to repeated failures');
    }
  }

  canAttempt(): boolean {
    if (this.state === 'CLOSED') return true;

    if (this.state === 'OPEN') {
      const elapsed = Date.now() - this.lastFailureTime;
      if (elapsed > this.timeout) {
        this.state = 'HALF_OPEN';
        console.log('[CircuitBreaker] Entering HALF_OPEN state');
        return true;
      }
      return false;
    }

    return this.state === 'HALF_OPEN';
  }

  getState() {
    return {
      state: this.state,
      failureCount: this.failureCount,
      timeSinceLastFailure: Date.now() - this.lastFailureTime
    };
  }

  // 手動でリセット
  reset() {
    this.failureCount = 0;
    this.state = 'CLOSED';
    console.log('[CircuitBreaker] Manually reset to CLOSED');
  }
}

//  모니터링エンドポイント
app.get('/api/circuit-breaker/status', (req, res) => {
  res.json(monitor.getState());
});

app.post('/api/circuit-breaker/reset', (req, res) => {
  monitor.reset();
  res.json({ success: true });
});

関連リソース
関連記事