TopNetworks API

curl "https://topnetworks.com/api/v1/freshness?provider=openai"
# { "provider": "openai", "fresh": true, "age_seconds": 42,
#   "drift_score": 0.04, "trend": "stable", "avg_response_ms": 118 }

const f = await fetch("https://topnetworks.com/api/v1/freshness?provider=openai").then(r => r.json())
if (!f.fresh) console.warn(`Data is ${f.age_seconds}s old — stale`)
if (f.drift_score > 0.3) console.warn("Latency volatile — consider failover")
console.log(f.trend)  // "stable" | "improving" | "degrading"

// "Before I set my timeout, what is OpenAI's p95 right now?"
const data = await fetch(
  "https://topnetworks.com/api/v1/latency?provider=openai&window=1h"
).then(r => r.json())
// { p50_ms: 312, p95_ms: 1840, p99_ms: 4200, avg_ms: 480,
//   ttft_estimate_ms: 192, trend: "stable", uptime_pct_in_window: 100 }

const timeout = Math.round(data.p95_ms * 1.2)  // p95 + 20% buffer
console.log("Use timeout:", timeout, "ms")       // 2208ms

const { entries } = await fetch(
  "https://topnetworks.com/api/v1/changelog?days=7"
).then(r => r.json())

// entries: [
//   { date: "2026-03-21", provider_id: "anthropic", type: "status_change",
//     description: "Status changed from operational to degraded",
//     details: { from: "operational", to: "degraded" } },
//   { date: "2026-03-20", provider_id: "openai", ... },
// ]

const outages = entries.filter(e => e.details.to === 'outage')
console.log(`${outages.length} outages in the last 7 days`)

const { pick, runners_up } = await fetch(
  "https://topnetworks.com/api/v1/pick?task=llm&min_context=128000&needs=vision"
).then(r => r.json())

// pick: {
//   provider_id: "google-gemini", model: "gemini-2.0-flash",
//   status: "operational", response_time_ms: 98,
//   input_per_1m_usd: 0.10, context_window: 1048576,
//   capabilities: { vision: true, function_calling: true, json_mode: true },
//   score: 105, reason: "Operational, fastest, $0.1/1M input, 1048K context, free tier available"
// }

const provider = pick.provider_id  // "google-gemini"
const fallback = runners_up[0]?.provider_id  // next best option

const { comparison } = await fetch(
  "https://topnetworks.com/api/v1/compare?providers=openai,anthropic,deepseek&metrics=status,price,benchmarks"
).then(r => r.json())

// comparison: {
//   openai: {
//     name: "OpenAI", status: "operational", response_time_ms: 197,
//     pricing: { model: "gpt-4o", input_per_1m_usd: 2.50, output_per_1m_usd: 10.00 },
//     benchmarks: { model: "o3", mmlu: 96.7, humaneval: 98, math: 97 }
//   },
//   anthropic: { ... },
//   deepseek: { ... }
// }

// Find cheapest operational provider
const cheapest = Object.entries(comparison)
  .filter(([, v]) => v.status === "operational" && v.pricing)
  .sort(([, a], [, b]) => a.pricing.input_per_1m_usd - b.pricing.input_per_1m_usd)[0]

const { results } = await fetch(
  "https://topnetworks.com/api/v1/cheapest?task=llm&min_quality=mmlu:85&limit=3"
).then(r => r.json())

// results: [
//   { provider_id: "deepseek", model: "deepseek-v3", status: "operational",
//     estimated_cost_usd: 0.82, input_per_1m_usd: 0.27,
//     quality_score: { mmlu: 88.5 }, free_tier: true },
//   { provider_id: "groq", model: "llama-3.3-70b", estimated_cost_usd: 0.985, ... },
// ]

const cheapestOperational = results.find(r => r.status === "operational")
console.log(`Use ${cheapestOperational.provider_id} at $${cheapestOperational.estimated_cost_usd}/1M tokens`)

const { failover_chain } = await fetch(
  "https://topnetworks.com/api/v1/failover?primary=openai&task=llm&max_cost_per_1m=2.00"
).then(r => r.json())

// failover_chain: [
//   { provider_id: "anthropic", status: "operational", score: 88,
//     response_time_ms: 390, input_per_1m_usd: 3.00,
//     reason: "Operational — 20% more expensive than OpenAI" },
//   { provider_id: "groq", status: "operational", score: 85,
//     response_time_ms: 180, input_per_1m_usd: 0.59,
//     reason: "Operational and fast — 76% cheaper than OpenAI" },
// ]

for (const p of failover_chain) {
  if (p.status === 'operational') {
    reroute(p.provider_id)  // try in order
    break
  }
}

const { recommendations } = await fetch(
  "https://topnetworks.com/api/v1/recommend?task=llm&avoid=openai&limit=3"
).then(r => r.json())

// [{ id: "anthropic", name: "Anthropic", status: "operational",
//    response_time_ms: 98, score: 90, reason: "Operational and fast" },
//  { id: "groq", ... }, ...]

const fallback = recommendations[0]?.id  // "anthropic"

const { incidents, summary } = await fetch(
  "https://topnetworks.com/api/v1/incidents?hours=24"
).then(r => r.json())

// summary: { total_incidents: 2, outages: 1, degraded: 1, ongoing: 1 }
// incidents[0]: { provider_id: "scaleway", severity: "degraded",
//   started_at: "2026-03-15T...", duration_minutes: 45, ongoing: true }

const data = await fetch(
  "https://topnetworks.com/api/v1/cost-estimate" +
  "?provider=openai&input_tokens=10000&output_tokens=2000&cached_tokens=5000"
).then(r => r.json())

// {
//   model: "gpt-4o",
//   rates: { input_per_1m_usd: 2.50, output_per_1m_usd: 10.00, cache_discount_pct: 50 },
//   breakdown: { input_cost_usd: 0.0125, cached_cost_usd: 0.00625, output_cost_usd: 0.02 },
//   estimated_total_usd: 0.038750,
//   cache_savings_usd: 0.00625,
//   cheaper_alternatives: [
//     { provider_id: "groq", input_per_1m_usd: 0.59,
//       estimated_total_usd: 0.009900, savings_pct: 74 }
//   ]
// }

const { pricing } = await fetch(
  "https://topnetworks.com/api/v1/pricing?task=llm&compare=true"
).then(r => r.json())
// Sorted cheapest input first:
// [{ provider_id: "deepinfra", model: "llama-3.3-70b",
//    pricing: { input_per_1m_tokens: 0.23, output_per_1m_tokens: 0.40 } },
//  { provider_id: "groq", ... }, ...]

const { models } = await fetch(
  "https://topnetworks.com/api/v1/models?task=llm&vision=true&min_context=128000"
).then(r => r.json())
// [{ provider_id: "google-gemini", model_id: "gemini-2.0-flash",
//    context_window: 1048576, max_output_tokens: 8192,
//    capabilities: { vision: true, function_calling: true, json_mode: true },
//    knowledge_cutoff: "2025-01" }, ...]

const { rate_limits } = await fetch(
  "https://topnetworks.com/api/v1/rate-limits?provider=openai"
).then(r => r.json())
// [{ tier: "free", limits: { requests_per_minute: 3, tokens_per_minute: 40000 } },
//  { tier: "tier1", limits: { requests_per_minute: 500, tokens_per_minute: 200000 } }]

const { benchmarks, meta } = await fetch(
  "https://topnetworks.com/api/v1/benchmarks?task=coding&limit=5"
).then(r => r.json())
// meta.sorted_by: "humaneval"
// benchmarks[0]: { provider_id: "openai", model_id: "o3",
//   scores: { humaneval: 98.0, mmlu: 96.7, math: 97.0 } }

const data = await fetch(
  "https://topnetworks.com/api/v1/quota-check?provider=groq&planned_rpm=25&planned_tpm=5000"
).then(r => r.json())

// {
//   provider: "groq", tier: "free",
//   planned: { rpm: 25, tpm: 5000 },
//   limits: { rpm: 30, rpd: 14400, tpm: 6000, tpd: 500000 },
//   verdict: "tight",
//   details: {
//     rpm: { status: "tight", usage_pct: 83, headroom: 5 },
//     tpm: { status: "tight", usage_pct: 83, headroom: 1000 }
//   },
//   suggestions: [
//     { provider_id: "cerebras", tier: "free", rpm: 30, tpm: 60000 }
//   ]
// }

if (data.verdict === 'exceeds') {
  console.log("Switch to:", data.suggestions[0]?.provider_id)
}

// Agent attests its output
const { attestation_id, verify_url } = await fetch('https://topnetworks.com/api/v1/attest', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    provider: 'openai',
    model: 'gpt-4o',
    output: 'The capital of France is Paris.',
    agent_id: 'my-agent-v1',
  }),
}).then(r => r.json())
// { attestation_id: "a1b2c3...", verify_url: "https://topnetworks.com/api/v1/validate/a1b2c3..." }

// Orchestrator hands task to researcher
const { handoff_id, verify_url } = await fetch('https://topnetworks.com/api/v1/handoff', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    from_agent: 'orchestrator-v1',
    to_agent: 'researcher-v2',
    task_id: 'task-abc-123',
    context: 'Research Q1 2026 AI market trends.',
  }),
}).then(r => r.json())
// { handoff_id: "h1b2c3...", verify_url: "https://topnetworks.com/api/v1/validate/h1b2c3..." }

// Step 1: Subscribe to OpenAI + Anthropic outages
const sub = await fetch("https://topnetworks.com/api/v1/webhooks", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    callback_url: "https://your-agent.com/hooks/topnetworks",
    events: ["provider.down", "provider.up", "incident.new"],
    providers: ["openai", "anthropic"],
    secret: "your-hmac-secret",
    expires_in_hours: 720,  // 30 days
  })
}).then(r => r.json())

console.log(sub.subscription.id)  // UUID — save this to manage later

// Your endpoint receives POSTs like:
// Headers:
//   X-TopNetworks-Event: provider.down
//   X-TopNetworks-Signature: a1b2c3...  (HMAC-SHA256 with your secret)
// Body:
// { "event": "provider.down", "timestamp": "...",
//   "payload": { "provider_id": "openai", "previous_status": "operational",
//     "current_status": "outage", "description": "..." } }

// Verify HMAC signature
import { createHmac } from 'crypto'
const sig = createHmac('sha256', 'your-hmac-secret').update(rawBody).digest('hex')
if (sig !== headers['x-topnetworks-signature']) throw new Error('Bad sig')

// Check subscription health
const status = await fetch(sub.verify_url).then(r => r.json())
console.log(status.subscription.fire_count)

// Unsubscribe
await fetch(sub.manage_url, { method: "DELETE" })

// Fetch the spec
const spec = await fetch("https://topnetworks.com/api/v1/openapi.json").then(r => r.json())
console.log(spec.info.title)    // "TopNetworks API"
console.log(Object.keys(spec.paths).length)  // 60

// Import into any OpenAPI client generator
// npx openapi-generator-cli generate -i https://topnetworks.com/api/v1/openapi.json -g python -o ./client

// Initialize
const init = await fetch("https://topnetworks.com/api/v1/mcp", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "initialize", params: {} })
}).then(r => r.json())
// { jsonrpc: "2.0", id: 1, result: { protocolVersion: "2024-11-05", capabilities: { tools: {} }, serverInfo: { name: "topnetworks" } } }

// List tools
const tools = await fetch("https://topnetworks.com/api/v1/mcp", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ jsonrpc: "2.0", id: 2, method: "tools/list", params: {} })
}).then(r => r.json())
// { result: { tools: [{ name: "topnetworks_health", ... }, { name: "topnetworks_pick", ... }, ...] } }

// Call a tool
const result = await fetch("https://topnetworks.com/api/v1/mcp", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    jsonrpc: "2.0", id: 3, method: "tools/call",
    params: { name: "topnetworks_pick", arguments: { task: "llm", needs: "vision" } }
  })
}).then(r => r.json())
// { result: { content: [{ type: "text", text: "{ pick: { provider_id: \"google-gemini\", ... } }" }] } }

const { sdk_support, meta } = await fetch(
  "https://topnetworks.com/api/v1/sdk-support?language=go&official_only=true"
).then(r => r.json())

// meta: { available_languages: ["python","node","go","java","rust","dotnet","dart","swift"] }
// sdk_support[0]: {
//   provider_id: "openai", openai_compat_sdk: false,
//   sdk_count: 1, languages: ["go"],
//   sdks: [{ language: "go", package_name: "openai-go",
//     official: true, repo_url: "https://github.com/openai/openai-go" }]
// }

const goProviders = sdk_support.map(r => r.provider_id)
console.log("Providers with official Go SDK:", goProviders)

const { changelog, meta } = await fetch(
  "https://topnetworks.com/api/v1/changelog/api?impact=high&days=30"
).then(r => r.json())

// meta: { by_type: { new_model: 3, deprecation: 1, breaking_change: 1 }, by_impact: { high: 5 } }
// changelog[0]: {
//   date: "2026-03-20", provider_id: "anthropic",
//   change_type: "new_model", impact: "high",
//   title: "Claude Opus 4.6 released",
//   description: "Improved agentic capabilities and adaptive thinking.",
//   affected_models: ["claude-opus-4.6"],
//   source_url: "https://docs.anthropic.com/en/docs/about-claude/models"
// }

const breaking = changelog.filter(e => e.change_type === "breaking_change")
if (breaking.length) console.warn("⚠️ Breaking changes:", breaking.map(e => e.title))

const { function_calling } = await fetch(
  "https://topnetworks.com/api/v1/function-calling?supported_only=true&parallel_only=true"
).then(r => r.json())

// function_calling[0]: {
//   provider_id: "openai", provider_name: "OpenAI",
//   tool_call_supported: true, parallel_calls_supported: true,
//   max_tools: 128, forced_mode: true,
//   tool_choice_options: ["auto", "none", "required", "function"],
//   notes: "Streaming function calls supported. Parallel since gpt-4-turbo."
// }

const parallel = function_calling.filter(r => r.parallel_calls_supported)
console.log(`${parallel.length} providers support parallel function calls`)

const { json_mode, meta } = await fetch(
  "https://topnetworks.com/api/v1/json-mode?schema_enforcement_only=true"
).then(r => r.json())

// meta: { schema_enforcement_count: 8, json_object_count: 22, no_native_support_count: 3 }
// json_mode[0]: {
//   provider_id: "openai", model_id: "gpt-4o",
//   json_object_supported: true, schema_enforcement_supported: true,
//   strict_mode_supported: true, enforcement_method: "native",
//   workaround_required: false, notes: "Use response_format: {type: 'json_schema'}"
// }

// Find providers that need a workaround
const workarounds = json_mode.filter(r => r.workaround_required)
console.log(`${workarounds.length} models need a prompt workaround for JSON`)

const { streaming_latency, meta } = await fetch(
  "https://topnetworks.com/api/v1/streaming-latency?sort=ttft"
).then(r => r.json())

// meta.benchmark_source: "artificialanalysis.ai + provider docs"
// streaming_latency[0]: {
//   provider_id: "groq", provider_name: "Groq",
//   model_id: "llama-3.3-70b", model_name: "Llama 3.3 70B",
//   median_ttft_ms: 218, p90_ttft_ms: 480,
//   median_tpt_ms: 14, throughput_tokens_per_sec: 285,
//   benchmark_source: "artificialanalysis.ai", measured_at: "2026-Q1"
// }

// Fastest TTFT for streaming chat
const fastest = streaming_latency[0]
console.log(`Fastest: ${fastest.provider_id} at ${fastest.median_ttft_ms}ms TTFT`)

const { deprecations, summary } = await fetch(
  "https://topnetworks.com/api/v1/deprecations?status=warning"
).then(r => r.json())

// summary: { active: 84, warning: 6, deprecated: 12, sunset: 4 }
// deprecations[0]: {
//   provider_id: "openai", model_id: "gpt-4-0314",
//   status: "deprecated", announced_at: "2023-06-13",
//   sunset_date: "2024-06-13", replacement_model: "gpt-4o",
//   notes: "Use gpt-4o. Price is 50% lower."
// }

const risky = deprecations.filter(r => r.status === 'warning' || r.status === 'deprecated')
console.log(`${risky.length} models at risk of breaking your agent`)

const { max_output_tokens } = await fetch(
  "https://topnetworks.com/api/v1/max-output-tokens?min_output=32000&task=llm"
).then(r => r.json())

// max_output_tokens[0]: {
//   provider_id: "anthropic", model_id: "claude-opus-4-5",
//   max_output_tokens: 64000, context_window: 200000,
//   output_to_context_ratio: 0.32,
//   notes: "64k output requires extended thinking mode."
// }

// Find models that can write a full book in one call
const longForm = max_output_tokens.filter(m => m.max_output_tokens >= 32000)
console.log(`${longForm.length} models support 32k+ output tokens`)

const { logprob_support, meta } = await fetch(
  "https://topnetworks.com/api/v1/logprob-support?supported_only=true"
).then(r => r.json())

// meta: { supported_count: 18, total: 52 }
// logprob_support[0]: {
//   provider_id: "openai", provider_name: "OpenAI",
//   logprob_supported: true, max_logprobs: 20,
//   top_logprobs_param: "top_logprobs",
//   notes: "Available on all chat completion models. Pass logprobs: true."
// }

console.log(`${meta.supported_count}/${meta.total} providers support logprobs`)

const { embedding_quality } = await fetch(
  "https://topnetworks.com/api/v1/embedding-quality?task_type=retrieval&limit=5"
).then(r => r.json())

// embedding_quality[0]: {
//   provider_id: "openai", provider_name: "OpenAI",
//   model_id: "text-embedding-3-large",
//   task_type: "retrieval", mteb_score: 62.3,
//   dimensions: 3072, notes: "Supports Matryoshka dimension reduction."
// }

// Pick best retrieval embedding for a RAG pipeline
const best = embedding_quality[0]
console.log(`Use ${best.model_id} — MTEB retrieval: ${best.mteb_score}`)

// Resolve a single alias
const result = await fetch(
  "https://topnetworks.com/api/v1/resolve-alias?alias=claude-sonnet-4-5"
).then(r => r.json())
// {
//   provider_id: "anthropic", alias: "claude-sonnet-4-5",
//   current_pinned_version: "claude-sonnet-4-5-20251001",
//   auto_updates: true, release_date: "2025-10-01",
//   notes: "Alias is auto-updated by Anthropic. Pin snapshot for production."
// }

// List all auto-updating aliases (production risk)
const { aliases } = await fetch(
  "https://topnetworks.com/api/v1/resolve-alias"
).then(r => r.json())
const risky = aliases.filter(a => a.auto_updates)
console.log(`${risky.length} aliases auto-update — check your hardcoded model IDs`)

const { model_versions } = await fetch(
  "https://topnetworks.com/api/v1/model-versions?has_breaking_changes=true"
).then(r => r.json())

// model_versions[0]: {
//   provider_id: "openai", alias: "gpt-4",
//   alias_auto_updates: true,
//   current_pinned_version: "gpt-4-0613",
//   pinnable: true,
//   versions: [
//     { version_id: "gpt-4-0125-preview", release_date: "2024-01-25" },
//     { version_id: "gpt-4-0613",         release_date: "2023-06-13" },
//   ],
//   breaking_changes: ["System prompt handling changed in 0125-preview"],
//   lifecycle_policy_url: "https://platform.openai.com/docs/deprecations"
// }

const breaking = model_versions.filter(m => m.breaking_changes.length > 0)
console.log(`${breaking.length} aliases have known breaking changes between versions`)

const { websocket_support, meta } = await fetch(
  "https://topnetworks.com/api/v1/websocket-support?websocket_only=true"
).then(r => r.json())

// meta: { websocket_count: 4, sse_only_count: 48 }
// websocket_support[0]: {
//   provider_id: "openai", websocket_supported: true,
//   streaming_method: "websocket", also_supports_sse: true,
//   use_case: "realtime_audio",
//   websocket_endpoint: "wss://api.openai.com/v1/realtime",
//   supported_models: ["gpt-4o-realtime-preview"],
//   auth_method: "bearer_token", multiplexing_supported: false,
//   notes: "Realtime API. Not available on standard chat endpoint."
// }

console.log(`Only ${meta.websocket_count} providers support WebSocket streaming`)

const { context_windows, meta } = await fetch(
  "https://topnetworks.com/api/v1/context-window?min_context=200000"
).then(r => r.json())

// Sorted by effective context, descending
// context_windows[0]: {
//   provider_id: "google-gemini", model_id: "gemini-2.5-pro",
//   advertised_context: 1048576, effective_context: 500000,
//   recommended_max_fill: 0.50, usable_tokens: 250000,
//   degradation_note: "1M advertised. Strong to ~500k, noticeable recall loss beyond."
// }

// Don't trust advertised — use effective
const safe = context_windows.filter(m => m.effective_context >= 200000)
console.log(`${safe.length} models with 200k+ effective context`)

const { thinking_support, meta } = await fetch(
  "https://topnetworks.com/api/v1/thinking-support?supported_only=true"
).then(r => r.json())

// meta: { thinking_capable: 11, visible_thinking: 8, budget_configurable: 7, always_on: 5 }
// thinking_support[0]: {
//   provider_id: "anthropic", model_id: "claude-opus-4",
//   thinking_supported: true, thinking_visible: true,
//   thinking_param: "thinking.type",
//   thinking_cost_per_1m: 60.00, budget_configurable: true,
//   budget_param: "thinking.budget_tokens (or adaptive)",
//   default_behavior: "opt_in",
//   notes: "Adaptive thinking recommended for Opus 4+."
// }

const cheapThinking = thinking_support
  .filter(m => m.thinking_cost_per_1m && m.thinking_cost_per_1m < 5)
  .sort((a, b) => a.thinking_cost_per_1m - b.thinking_cost_per_1m)
console.log("Cheapest reasoning:", cheapThinking[0]?.model_id)

const { multimodal, meta } = await fetch(
  "https://topnetworks.com/api/v1/multimodal?input_type=image"
).then(r => r.json())

// meta: { vision_capable: 12, audio_input: 3, video_input: 3, pdf_input: 5 }
// multimodal[0]: {
//   provider_id: "google-gemini", model_id: "gemini-2.5-pro",
//   inputs: ["text","image","audio","video","pdf"],
//   outputs: ["text","image","audio"],
//   max_images: 3600, max_image_size_mb: 20,
//   supported_image_formats: ["png","jpeg","gif","webp","heic","heif"]
// }

const pdfCapable = multimodal.filter(m => m.inputs.includes("pdf"))
console.log(`${pdfCapable.length} models accept native PDF input`)

const { structured_output, meta } = await fetch(
  "https://topnetworks.com/api/v1/structured-output?strict_only=true"
).then(r => r.json())

// meta: { strict_enforcement: 8, constrained_decoding: 5, no_structured_output: 3 }
// structured_output[0]: {
//   provider_id: "openai", model_id: "gpt-4o",
//   json_schema_supported: true, strict_enforcement: true,
//   constrained_decoding: true,
//   response_format_param: "response_format.type=json_schema",
//   supported_schema_features: ["object","array","enum","anyOf","nested","required"],
//   failure_mode: "error",
//   notes: "Best structured output support. Strict mode uses constrained decoding."
// }

// Which models will SILENTLY return invalid JSON?
const dangerous = structured_output.filter(m => m.failure_mode === "silent_invalid")
console.log("Avoid for structured tasks:", dangerous.map(m => m.model_id))

const { prompt_caching, meta } = await fetch(
  "https://topnetworks.com/api/v1/prompt-caching?supported_only=true"
).then(r => r.json())

// meta: { supported_count: 6, total: 52 }
// prompt_caching[0]: {
//   provider_id: "anthropic", provider_name: "Anthropic",
//   caching_supported: true, cache_ttl_minutes: 5,
//   savings_pct: 90,  // cached tokens cost 10% of full price
//   cacheable_elements: ["system", "tools", "messages"],
//   requires_explicit_markup: true,
//   uncached_input_price_per_mtoken: 3.00,
//   cached_input_price_per_mtoken: 0.30
// }

// Multi-agent loop: estimate monthly savings from caching 4k token system prompt
const anthropic = prompt_caching.find(r => r.provider_id === 'anthropic')
const saving = 4000 / 1e6 * anthropic.uncached_input_price_per_mtoken * (anthropic.savings_pct / 100)
console.log(`Save $${(saving * 1000).toFixed(4)} per 1000 requests with caching`)

const { batch_api, meta } = await fetch(
  "https://topnetworks.com/api/v1/batch-api?available_only=true"
).then(r => r.json())

// meta: { available_count: 5, total: 52 }
// batch_api[0]: {
//   provider_id: "openai", provider_name: "OpenAI",
//   batch_api_available: true,
//   discount_pct: 50,
//   max_batch_size: 50000,
//   typical_turnaround_hours: 24,
//   supported_endpoints: ["/v1/chat/completions", "/v1/embeddings"],
//   notes: "Results expire after 29 days. Use for evals, not real-time."
// }

// Pick cheapest batch provider
const best = batch_api.sort((a, b) => (b.discount_pct ?? 0) - (a.discount_pct ?? 0))[0]
console.log(`${best.provider_id} gives ${best.discount_pct}% batch discount`)

const { fine_tuning, meta } = await fetch(
  "https://topnetworks.com/api/v1/fine-tuning?available_only=true"
).then(r => r.json())

// meta: { available_count: 7, total: 52 }
// fine_tuning[0]: {
//   provider_id: "openai", provider_name: "OpenAI",
//   available: true,
//   methods: ["supervised", "dpo", "reinforcement"],
//   supported_models: ["gpt-4o-mini", "gpt-4o", "gpt-3.5-turbo"],
//   training_cost_per_1m_tokens: 25.00,
//   inference_cost_multiplier: 1.0,
//   max_training_examples: null,
//   notes: "Hyperparameter tuning available. Supports function calling fine-tuning."
// }

// Find cheapest fine-tuning option
const cheapest = fine_tuning.sort((a, b) =>
  (a.training_cost_per_1m_tokens ?? 999) - (b.training_cost_per_1m_tokens ?? 999)
)[0]
console.log(`Cheapest: ${cheapest.provider_id} at $${cheapest.training_cost_per_1m_tokens}/1M tokens`)

const { audio_pricing, meta } = await fetch(
  "https://topnetworks.com/api/v1/audio-pricing?type=stt"
).then(r => r.json())

// meta: { stt_count: 8, tts_count: 12, realtime_count: 3 }
// audio_pricing[0] (STT, cheapest):
// { provider_id: "groq", type: "stt", model: "whisper-large-v3-turbo",
//   price_per_minute: 0.0002, realtime_supported: false,
//   free_tier: "unlimited (rate limited)", notes: "Whisper-based, ~15x faster than OpenAI" }
// audio_pricing[N] (TTS):
// { provider_id: "openai", type: "tts", model: "tts-1",
//   price_per_1k_chars: 0.015, realtime_supported: false,
//   free_tier: null }

// Find cheapest STT for a transcription pipeline
const stt = audio_pricing.filter(r => r.type === 'stt')
console.log(`Cheapest STT: ${stt[0].provider_id} at $${stt[0].price_per_minute}/min`)

const { reranking, meta } = await fetch(
  "https://topnetworks.com/api/v1/reranking?available_only=true"
).then(r => r.json())

// meta: { available_count: 5, total: 52 }
// reranking[0]: {
//   provider_id: "cohere", provider_name: "Cohere",
//   reranking_available: true,
//   models: ["rerank-english-v3.0", "rerank-multilingual-v3.0"],
//   price_per_1k_queries: 2.00, max_documents: 1000,
//   supports_multilingual: true,
//   notes: "Industry standard. Also available via Azure / AWS."
// }

// Compare reranking costs for a RAG pipeline doing 100k queries/day
reranking.sort((a, b) => (a.price_per_1k_queries ?? 999) - (b.price_per_1k_queries ?? 999))
const cheapest = reranking[0]
console.log(`${cheapest.provider_id}: $${(cheapest.price_per_1k_queries / 1000 * 100000).toFixed(2)}/day`)

const { providers_ranked, meta } = await fetch(
  "https://topnetworks.com/api/v1/task-cost" +
  "?task_type=chat&input_tokens=50000&output_tokens=5000&limit=5"
).then(r => r.json())

// meta.cheapest_provider: "deepseek"
// providers_ranked[0]: {
//   rank: 1, provider_id: "deepseek", model: "deepseek-v3",
//   estimated_cost_usd: 0.017750,
//   input_cost_usd: 0.013500, output_cost_usd: 0.004250,
//   input_per_1m_usd: 0.27, output_per_1m_usd: 0.85,
//   pct_more_expensive_than_cheapest: 0,
//   free_tier: true
// }
// providers_ranked[4]: { pct_more_expensive_than_cheapest: 1240, ... }

console.log(`Cheapest: ${providers_ranked[0].provider_id} — $${providers_ranked[0].estimated_cost_usd.toFixed(6)}`)
console.log(`Most expensive is ${providers_ranked[4].pct_more_expensive_than_cheapest}% pricier`)

const { caching_granularity } = await fetch(
  "https://topnetworks.com/api/v1/caching-granularity?supports_caching=true"
).then(r => r.json())

// caching_granularity[0]: {
//   provider_id: "anthropic",
//   caching_supported: true, caching_type: "explicit",
//   cacheable_elements: ["system", "tools", "user_messages", "images"],
//   elements_cache_independently: true,
//   min_tokens_per_block: 1024,
//   max_cache_breakpoints: 4,
//   ttl_options_seconds: [300, 3600],
//   default_ttl_seconds: 300,
//   cached_price_pct_of_input: 10,  // 10% = 90% savings
//   requires_explicit_markup: true,
//   markup_method: "cache_control: { type: 'ephemeral' }",
//   notes: "Min 1024 tokens per cacheable block. Images count towards token limit."
// }

const { free_tiers, meta } = await fetch(
  "https://topnetworks.com/api/v1/free-tier?permanent_only=true"
).then(r => r.json())

// meta: { permanent_free_count: 14, trial_credit_count: 18, no_free_access_count: 20 }
// free_tiers[0]: {
//   provider_id: "google-gemini", provider_name: "Google Gemini",
//   has_free_tier: true, tier_type: "permanent",
//   requires_credit_card: false,
//   included_models: ["gemini-2.0-flash", "gemini-1.5-flash"],
//   monthly_token_cap: null,  // rate-limited but no hard cap
//   daily_request_cap: 1500, monthly_request_cap: null,
//   trial_credit_usd: null, trial_credit_recurring: false,
//   rate_limits_apply: true,
//   rate_limits_url: "/api/v1/rate-limits?provider=google-gemini&tier=free",
//   notes: "Flash free tier is generous. Pro models require billing."
// }

const noCard = free_tiers.filter(r => !r.requires_credit_card)
console.log(`${noCard.length} providers offer free access with no credit card`)

const data = await fetch("https://topnetworks.com/api/v1/token-estimate", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ text: "Your prompt text here...", provider: "openai" })
}).then(r => r.json())

// Single provider estimate:
// { estimate: { provider_id: "openai", tokenizer: "o200k_base (GPT-4o/o3)",
//   estimated_tokens: 7, confidence: "approximate",
//   token_range: { low: 6, high: 8 } },
//   input: { char_count: 27, word_count: 5 } }

// Without provider: returns all tokenizer estimates
// { estimates: [{ tokenizer: "o200k", estimated_tokens: 7, providers: ["openai"] }, ...],
//   summary: { min_tokens: 6, max_tokens: 8, avg_tokens: 7 } }

const { forecasts, usage_profile } = await fetch(
  "https://topnetworks.com/api/v1/cost-forecast?requests_per_day=500&avg_input_tokens=4000&avg_output_tokens=1000&cache_hit_rate=0.3"
).then(r => r.json())

// Ranked cheapest first
// forecasts[0]: {
//   provider_id: "deepseek", model: "DeepSeek V3",
//   daily_cost: 0.27, weekly_cost: 1.89,
//   monthly_cost: 8.10, yearly_cost: 98.55,
//   cost_breakdown: { daily_input_cost: 0.16, daily_output_cost: 0.11, cache_savings_per_day: 0.04 },
//   pricing: { input_per_1m: 0.27, output_per_1m: 1.10, caching_available: true }
// }

console.log(`Cheapest: $${forecasts[0].monthly_cost}/month on ${forecasts[0].provider_id}`)

const { compliance, meta } = await fetch(
  "https://topnetworks.com/api/v1/compliance?hipaa=true"
).then(r => r.json())

// meta: { gdpr_compliant_count: 28, hipaa_baa_count: 9, soc2_ii_count: 19 }
// compliance[0]: {
//   provider_id: "openai", provider_name: "OpenAI",
//   certifications: ["soc2", "hipaa", "gdpr"],
//   soc2_type: "II",
//   hipaa_baa_available: true,
//   gdpr_compliant: true,
//   dpa_available: true,
//   iso27001: false,
//   pci_dss: false,
//   fedramp: false,
//   notes: "BAA available under Enterprise plan. Zero data retention configurable."
// }

// Filter for EU healthcare use case
const euHealth = compliance.filter(r => r.hipaa_baa_available && r.gdpr_compliant)
console.log(`${euHealth.length} providers suitable for EU healthcare data`)

const { data_retention, meta } = await fetch(
  "https://topnetworks.com/api/v1/data-retention?no_training=true"
).then(r => r.json())

// meta: { zdr_available_count: 8, trains_on_data_count: 3 }
// data_retention[0]: {
//   provider_id: "anthropic", provider_name: "Anthropic",
//   prompt_logging: "30_days",
//   retention_period_days: 30,
//   opt_out_available: true,
//   opt_out_method: "account_setting",
//   zero_data_retention_available: true,
//   zdr_plan_required: "enterprise",
//   trained_on_api_data: false,
//   notes: "Prompts not used for training by default. ZDR on Enterprise plan."
// }

const noLog = data_retention.filter(r => !r.trained_on_api_data && r.opt_out_available)
console.log(`${noLog.length} providers don't train on data + offer opt-out`)

const { sla, meta } = await fetch(
  "https://topnetworks.com/api/v1/sla?sla_available_only=true&min_uptime=99.9"
).then(r => r.json())

// meta: { sla_available_count: 12 }
// sla[0]: {
//   provider_id: "openai", provider_name: "OpenAI",
//   sla_available: true,
//   guaranteed_uptime_pct: 99.9,
//   credit_pct_per_hour_outage: 10,
//   max_credit_pct: 30,
//   tier_required: "enterprise",
//   sla_url: "https://openai.com/enterprise",
//   notes: "SLA applies to API. Consumer products have no SLA."
// }

// Cross-check SLA guarantee vs observed uptime
const { sla: slaRecord } = await fetch("/api/v1/sla?provider=openai").then(r => r.json())
const { overall_uptime_pct } = await fetch("/api/v1/uptime-history?provider=openai&period=30d").then(r => r.json())
console.log(`Promised: ${slaRecord[0].guaranteed_uptime_pct}% | Observed: ${overall_uptime_pct}%`)

const { overflow_behaviour, summary } = await fetch(
  "https://topnetworks.com/api/v1/overflow-behaviour"
).then(r => r.json())

// summary: {
//   error: 31, truncate: 14, sliding_window: 7,
//   silent_truncators: ["mistral", "together-ai"]  // truncate with no warning_provided
// }
// overflow_behaviour[0]: {
//   provider_id: "openai", overflow_behaviour: "error",
//   warning_provided: true,
//   error_code: "context_length_exceeded",
//   notes: "Returns 400 with max_tokens hint. Use tiktoken to count before sending."
// }

// Find dangerous silent truncators for a long-context agent
const silent = overflow_behaviour.filter(r =>
  r.overflow_behaviour === 'truncate' && !r.warning_provided
)
console.warn(`AVOID for long context: ${silent.map(r => r.provider_id).join(', ')}`)

const { openai_compat, meta } = await fetch(
  "https://topnetworks.com/api/v1/openai-compat?drop_in_only=true"
).then(r => r.json())

// meta: { compatible_count: 24, drop_in_count: 11 }
// openai_compat[0]: {
//   provider_id: "groq", provider_name: "Groq",
//   openai_compatible: true,
//   drop_in_replacement: true,
//   base_url: "https://api.groq.com/openai/v1",
//   compatible_endpoints: ["/chat/completions", "/models"],
//   known_quirks: ["No streaming function calls", "tool_choice 'required' not supported"],
//   notes: "Change base_url + model name. Most OpenAI SDK code works unchanged."
// }

// Migrate from OpenAI in one line
const groq = openai_compat.find(r => r.provider_id === 'groq')
// openai.baseURL = groq.base_url  → done

const { error_codes, meta } = await fetch(
  "https://topnetworks.com/api/v1/error-codes?category=rate_limit&retryable_only=true"
).then(r => r.json())

// meta: { categories: ["rate_limit","auth","context_length","content_filter","server_error","timeout"] }
// error_codes[0]: {
//   provider_id: "openai", http_status: 429,
//   provider_error_type: "rate_limit_exceeded",
//   provider_error_code: "rate_limit_exceeded",
//   standard_category: "rate_limit",
//   retryable: true,
//   recommended_backoff_ms: 1000,
//   max_retries: 5,
//   resolution: "Exponential backoff. Check x-ratelimit-reset-requests header.",
//   notes: "Different limits for tokens vs requests."
// }

// Generic retry handler for any provider
function shouldRetry(error, provider) {
  const codes = error_codes.filter(c =>
    c.provider_id === provider && c.http_status === error.status
  )
  return codes.some(c => c.retryable)
}

const { rate_limit_recovery } = await fetch(
  "https://topnetworks.com/api/v1/rate-limit-recovery?provider=openai"
).then(r => r.json())

// rate_limit_recovery[0]: {
//   provider_id: "openai",
//   retry_after_header: "retry-after",
//   retry_after_format: "seconds",
//   reset_headers: ["x-ratelimit-reset-requests", "x-ratelimit-reset-tokens"],
//   reset_header_format: "iso8601",
//   rpm_window_type: "sliding",
//   tpm_window_type: "sliding",
//   recommended_strategy: "exponential_backoff_with_jitter",
//   base_delay_ms: 1000,
//   max_delay_ms: 60000,
//   jitter: true,
//   notes: "Read x-ratelimit-reset-requests for exact reset time. Always add jitter."
// }

// Build a correct retry loop from the data
const { base_delay_ms, max_delay_ms, jitter } = rate_limit_recovery[0]
const delay = attempt => Math.min(base_delay_ms * 2 ** attempt, max_delay_ms)
const withJitter = ms => ms * (0.5 + Math.random() * 0.5)
// retryDelay = jitter ? withJitter(delay(attempt)) : delay(attempt)

const { regions, meta } = await fetch(
  "https://topnetworks.com/api/v1/regions?eu_only=true"
).then(r => r.json())

// meta: { eu_available_count: 18, us_available_count: 42, ap_available_count: 22 }
// regions[0]: {
//   provider_id: "azure-openai", provider_name: "Azure OpenAI",
//   inference_regions: [
//     { region_id: "swedencentral", name: "Sweden Central",
//       geography: "eu", models: ["gpt-4o", "gpt-4o-mini"] },
//     { region_id: "westeurope",    name: "West Europe", geography: "eu", models: null }
//   ],
//   geographies: ["us", "eu", "ap"],
//   eu_available: true,
//   notes: "Model availability varies by region. Check Azure portal for current availability."
// }

// Find EU-only providers for GDPR-sensitive workloads
const euOnly = regions.filter(r => r.geographies.length === 1 && r.eu_available)
console.log(`${euOnly.length} providers with EU inference only`)

const data = await fetch(
  "https://topnetworks.com/api/v1/uptime-history?provider=openai&period=30d"
).then(r => r.json())

// {
//   provider: "openai", period: "30d", granularity: "daily",
//   overall_uptime_pct: 99.4,
//   sla_target: 99.9, sla_met: false,
//   incidents_in_period: 2,
//   timeline: [
//     { date: "2026-03-24", uptime_pct: 100, total_checks: 144, outage_checks: 0 },
//     { date: "2026-03-23", uptime_pct: 93.8, total_checks: 144, outage_checks: 9 },
//     ...
//   ]
// }

if (!data.sla_met) {
  console.warn(`${data.provider} is below its ${data.sla_target}% SLA — observed: ${data.overall_uptime_pct}%`)
}
// Plot the timeline for a dashboard
const worstDay = data.timeline.sort((a, b) => a.uptime_pct - b.uptime_pct)[0]
console.log(`Worst day: ${worstDay.date} at ${worstDay.uptime_pct}% uptime`)

const { guardrails, meta } = await fetch(
  "https://topnetworks.com/api/v1/guardrails?can_disable=true"
).then(r => r.json())

// meta: { can_disable: 3, no_filters: 4, high_false_positive: 1 }
// guardrails[0]: {
//   provider_id: "google-gemini",
//   safety_filters_enabled: true, configurable: true,
//   filter_categories: ["harassment","hate_speech","sexually_explicit","dangerous_content"],
//   strictness_levels: ["BLOCK_NONE","BLOCK_ONLY_HIGH","BLOCK_MEDIUM_AND_ABOVE","BLOCK_LOW_AND_ABOVE"],
//   can_disable: true, false_positive_risk: "high",
//   notes: "Most aggressive default filters. BLOCK_NONE available..."
// }

const { rate_limit_status } = await fetch(
  "https://topnetworks.com/api/v1/rate-limit-status"
).then(r => r.json())

// Sorted by congestion severity (worst first)
// rate_limit_status[0]: {
//   provider_id: "deepseek", congestion: "high",
//   avg_response_time_ms: 4200, p95_response_time_ms: 8100,
//   response_time_trend: 0.35, error_rate_1h: 0.08,
//   recommendation: "Expect slower responses — consider alternatives"
// }

const avoid = rate_limit_status
  .filter(r => r.congestion === "critical" || r.congestion === "high")
  .map(r => r.provider_id)
console.log("Avoid:", avoid)  // Use with /api/v1/pick?avoid=...

const { migration_guides } = await fetch(
  "https://topnetworks.com/api/v1/migration-guide?from=openai&to=deepseek"
).then(r => r.json())

// migration_guides[0]: {
//   from_provider: "openai", to_provider: "deepseek",
//   difficulty: "drop_in", openai_compat: true,
//   param_changes: [{ from: "base_url=api.openai.com", to: "base_url=api.deepseek.com" }],
//   missing_features: ["vision (V3 only)","audio","structured outputs (R1)"],
//   auth_change: "Same Authorization: Bearer format. Different API key.",
//   gotchas: [
//     "DeepSeek-R1 does NOT support JSON mode — use V3 for structured output",
//     "R1 thinking tokens counted toward context window",
//     "Rate limits are lower than OpenAI"
//   ]
// }

const { data } = await fetch(
  "https://topnetworks.com/api/v1/agent-protocols?protocol=MCP&support_level=native"
).then(r => r.json())

// data[0]: {
//   provider_id: "anthropic", provider_name: "Anthropic",
//   protocol: "MCP", support_level: "native",
//   version: "2025-03-26",
//   notes: "MCP creator. Native MCP client in API and Claude desktop.",
//   docs_url: "https://docs.anthropic.com/en/docs/build-with-claude/mcp"
// }

const { data } = await fetch(
  "https://topnetworks.com/api/v1/knowledge-cutoff?after=2024-12-01"
).then(r => r.json())

// data[0]: {
//   provider_id: "anthropic", model_id: "claude-opus-4",
//   cutoff_date: "2025-03-01", cutoff_approximate: true,
//   notes: "Most recent Anthropic cutoff. Training through early 2025.",
//   docs_url: "https://docs.anthropic.com/en/docs/about-claude/models"
// }

const { data } = await fetch(
  "https://topnetworks.com/api/v1/tool-call-format?provider=anthropic"
).then(r => r.json())

// data[0]: {
//   provider_id: "anthropic", model_id: null,
//   role_order: ["user","assistant","user"],
//   tool_call_role: "assistant", tool_result_role: "user",
//   tool_result_content_key: "content",
//   parallel_tool_calls: true, strict_role_ordering: true,
//   tool_schema_format: "anthropic-v1",
//   notes: "Tool results sent as user messages with type:tool_result blocks."
// }

const { data, meta } = await fetch(
  "https://topnetworks.com/api/v1/streaming-protocols?protocol=WebSocket"
).then(r => r.json())

// meta.websocket_count: 3
// data[0]: {
//   provider_id: "openai", primary_protocol: "both",
//   sse_supported: true, websocket_supported: true,
//   supported_events: ["content.delta","message.stop","tool_calls.delta",...],
//   stream_end_signal: "[DONE]", realtime_api: true,
//   known_quirks: "Realtime API uses WebSocket for voice/audio."
// }

const { data } = await fetch(
  "https://topnetworks.com/api/v1/output-reproducibility?deterministic_only=true"
).then(r => r.json())

// data[0]: {
//   provider_id: "openai", seed_supported: true, seed_param: "seed",
//   deterministic_guarantee: "best_effort",
//   same_hardware_required: true, system_fingerprint_exposed: true,
//   known_variability_factors: ["model updates","infrastructure changes","different system_fingerprint"],
//   notes: "When seed is set and system_fingerprint matches, outputs are highly reproducible."
// }

const { data } = await fetch(
  "https://topnetworks.com/api/v1/native-tools?tool_type=web_search"
).then(r => r.json())

// data[0]: {
//   provider_id: "perplexity", tool_name: "web_search",
//   tool_type: "web_search",
//   compatible_models: ["sonar","sonar-pro","sonar-reasoning","sonar-reasoning-pro"],
//   separate_pricing: false,
//   pricing_notes: "Web search is intrinsic to all Sonar models — no additional charge",
//   availability: "ga"
// }

const { data } = await fetch(
  "https://topnetworks.com/api/v1/model-task-fit?task=reasoning&tier=elite"
).then(r => r.json())

// data sorted by score desc:
// [
//   { provider_id: "openai", model_id: "o3", task: "reasoning", score: 98, tier: "elite" },
//   { provider_id: "deepseek", model_id: "deepseek-r1", task: "reasoning", score: 96, tier: "elite" },
//   { provider_id: "anthropic", model_id: "claude-opus-4", task: "reasoning", score: 95, tier: "elite" },
//   { provider_id: "google-gemini", model_id: "gemini-2.5-pro", task: "reasoning", score: 94, tier: "elite" },
// ]

const { data } = await fetch(
  "https://topnetworks.com/api/v1/pii-handling?redaction=true"
).then(r => r.json())

// data[0]: {
//   provider_id: "aws-bedrock", pii_detection_supported: true,
//   pii_redaction_supported: true,
//   supported_pii_types: ["name","email","phone","address","ssn","credit_card",...],
//   detection_in_prompt: true, detection_in_response: true,
//   audit_trail_supported: true, configurable: true,
//   notes: "Amazon Bedrock Guardrails: comprehensive PII detection + redaction."
// }

const { data, meta } = await fetch(
  "https://topnetworks.com/api/v1/context-compression?native_only=true"
).then(r => r.json())

// meta.native_compression_count: 1
// data[0]: {
//   provider_id: "google-gemini", native_compression: true,
//   compression_methods: ["key_extraction"],
//   prompt_caching_as_compression: true, auto_compression: true,
//   ttl_configurable: true,
//   notes: "Context Caching API allows caching large stable context chunks."
// }

const { data, summary } = await fetch(
  "https://topnetworks.com/api/v1/security-certifications?certification=HIPAA&status=certified"
).then(r => r.json())

// data[0]: {
//   provider_id: "aws-bedrock", certification: "HIPAA", status: "certified",
//   scope: "AWS Bedrock covered under AWS HIPAA BAA"
// }
// summary: [{ provider_id: "azure-openai", certified_count: 7, certifications: [...] }, ...]

const { data, meta } = await fetch(
  "https://topnetworks.com/api/v1/semantic-caching?provider=openai"
).then(r => r.json())

// meta.note: "As of 2026-03, no major LLM provider offers native semantic caching."
// data[0]: {
//   provider_id: "openai", semantic_caching_supported: false,
//   caching_type: "exact_match", similarity_threshold_configurable: false,
//   cache_scope: "org", ttl_configurable: false,
//   notes: "Prompt caching uses prefix matching (exact_match on token prefix). No semantic similarity."
// }

const { data, meta } = await fetch(
  "https://topnetworks.com/api/v1/mcp-support?client=true"
).then(r => r.json())

// meta.mcp_client_count: 5
// data[0]: {
//   provider_id: "anthropic", mcp_server_supported: true, mcp_client_supported: true,
//   mcp_version: "2025-03-26",
//   hosted_mcp_servers: ["filesystem","github","postgres","puppeteer","brave-search","google-maps"],
//   custom_mcp_server_support: true,
//   notes: "MCP creators. Native client in Claude API."
// }

const { data, meta } = await fetch(
  "https://topnetworks.com/api/v1/model-lifecycle?deprecated_only=true"
).then(r => r.json())

// meta: { deprecated_count: 8, sunset_count: 3 }
// data[0]: {
//   provider_id: "openai", model_id: "gpt-4-turbo",
//   stage: "soft_deprecated", launch_date: "2023-11-06",
//   deprecation_date: "2025-04-01",
//   replacement_model: "gpt-4o", sla_eligible: false,
//   notes: "Replaced by gpt-4o. Migrate at your earliest convenience."
// }

const { data } = await fetch(
  "https://topnetworks.com/api/v1/delegation-support?provider=aws-bedrock"
).then(r => r.json())

// data[0]: {
//   provider_id: "aws-bedrock", delegation_supported: true,
//   protocol: "IAM + Bedrock Agents", time_bound: true,
//   auditable: true, revocable: true,
//   notes: "IAM roles + Bedrock Agents chaining. Time-bound via STS AssumeRole. CloudTrail audit."
// }

const { data, meta } = await fetch(
  "https://topnetworks.com/api/v1/prompt-moderation?injection_detection=true"
).then(r => r.json())

// meta.injection_detection_count: 2
// data[0]: {
//   provider_id: "aws-bedrock", input_moderation_supported: true,
//   prompt_injection_detection: true,
//   supported_categories: ["hate","insults","sexual","violence","prompt_attack",...],
//   moderation_action: ["block","flag"],
//   configurable: true, separate_moderation_api: false,
//   latency_impact: "medium",
//   notes: "Bedrock Guardrails: Prompt Attack detection for injection."
// }