aistatus 0.0.2

package/dist/index.cjs

@@ -0,0 +1,1101 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AIStatusError: () => AIStatusError,
+  AllProvidersDown: () => AllProvidersDown,
+  CheckAPIUnreachable: () => CheckAPIUnreachable,
+  CheckResult: () => CheckResult,
+  NoBudgetMatch: () => NoBudgetMatch,
+  ProviderAdapter: () => ProviderAdapter,
+  ProviderCallFailed: () => ProviderCallFailed,
+  ProviderNotConfigured: () => ProviderNotConfigured,
+  ProviderNotInstalled: () => ProviderNotInstalled,
+  RouteResponse: () => RouteResponse,
+  Router: () => Router,
+  Status: () => Status,
+  StatusAPI: () => StatusAPI,
+  VERSION: () => VERSION,
+  aroute: () => aroute,
+  createAdapter: () => createAdapter,
+  registerAdapterType: () => registerAdapterType,
+  route: () => route
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var AIStatusError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var AllProvidersDown = class extends AIStatusError {
+  tried;
+  constructor(tried) {
+    super(
+      `All providers unavailable. Tried: ${tried.join(", ")}. Check https://aistatus.cc for current status.`
+    );
+    this.tried = tried;
+  }
+};
+var ProviderCallFailed = class extends AIStatusError {
+  provider;
+  model;
+  cause;
+  constructor(provider, model, cause) {
+    super(`${provider} (${model}) call failed: ${String(cause)}`);
+    this.provider = provider;
+    this.model = model;
+    this.cause = cause;
+  }
+};
+var NoBudgetMatch = class extends AIStatusError {
+  maxCost;
+  tier;
+  constructor(maxCost, tier) {
+    super(`No operational model in tier '${tier}' under $${maxCost}/M tokens.`);
+    this.maxCost = maxCost;
+    this.tier = tier;
+  }
+};
+var ProviderNotConfigured = class extends AIStatusError {
+  provider;
+  envName;
+  constructor(provider, envName) {
+    super(
+      envName ? `Provider '${provider}' is not configured. Set ${envName} or pass apiKey explicitly.` : `Provider '${provider}' is not configured. Pass apiKey explicitly.`
+    );
+    this.provider = provider;
+    this.envName = envName;
+  }
+};
+var ProviderNotInstalled = class extends AIStatusError {
+  provider;
+  packageName;
+  constructor(provider, packageName) {
+    super(
+      packageName ? `Provider '${provider}' requires package '${packageName}'.` : `Provider '${provider}' is not available in this runtime.`
+    );
+    this.provider = provider;
+    this.packageName = packageName;
+  }
+};
+var CheckAPIUnreachable = class extends AIStatusError {
+  constructor() {
+    super(
+      "Could not reach aistatus.cc API. Proceeding with provider inference only."
+    );
+  }
+};
+
+// src/http.ts
+var HTTPStatusError = class extends Error {
+  status;
+  body;
+  constructor(status, body) {
+    super(`HTTP ${status}`);
+    this.name = "HTTPStatusError";
+    this.status = status;
+    this.body = body;
+  }
+};
+function readEnv(name) {
+  if (!name) {
+    return void 0;
+  }
+  if (typeof process === "undefined" || !process.env) {
+    return void 0;
+  }
+  return process.env[name];
+}
+function requireApiKey(provider, apiKey, envName) {
+  if (!apiKey) {
+    throw new ProviderNotConfigured(provider, envName);
+  }
+  return apiKey;
+}
+function joinUrl(baseUrl, path) {
+  return `${baseUrl.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
+}
+function extractText(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => extractText(item)).filter(Boolean).join("\n");
+  }
+  if (isRecord(value)) {
+    if (typeof value.text === "string") {
+      return value.text;
+    }
+    if ("content" in value) {
+      return extractText(value.content);
+    }
+  }
+  return "";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function fetchJson(url, init = {}) {
+  const controller = new AbortController();
+  const timeoutMs = init.timeoutMs ?? 3e3;
+  const timeoutId = setTimeout(() => {
+    controller.abort(new Error(`Request timed out after ${timeoutMs}ms`));
+  }, timeoutMs);
+  const externalSignal = init.signal;
+  const abortFromExternal = () => {
+    controller.abort(externalSignal?.reason);
+  };
+  if (externalSignal) {
+    if (externalSignal.aborted) {
+      controller.abort(externalSignal.reason);
+    } else {
+      externalSignal.addEventListener("abort", abortFromExternal, {
+        once: true
+      });
+    }
+  }
+  try {
+    const headers = new Headers(init.headers ?? {});
+    let body = init.body;
+    if (body !== void 0 && body !== null && typeof body !== "string" && !(body instanceof URLSearchParams) && !(body instanceof FormData) && !(body instanceof Blob) && !(body instanceof ArrayBuffer)) {
+      body = JSON.stringify(body);
+    }
+    if (typeof body === "string" && !headers.has("content-type")) {
+      headers.set("content-type", "application/json");
+    }
+    const response = await fetch(url, {
+      ...init,
+      headers,
+      body,
+      signal: controller.signal
+    });
+    const text = await response.text();
+    const payload = text ? tryParseJson(text) : null;
+    if (!response.ok) {
+      throw new HTTPStatusError(response.status, payload);
+    }
+    return payload;
+  } finally {
+    clearTimeout(timeoutId);
+    externalSignal?.removeEventListener("abort", abortFromExternal);
+  }
+}
+function tryParseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+// src/models.ts
+var Status = /* @__PURE__ */ ((Status2) => {
+  Status2["OPERATIONAL"] = "operational";
+  Status2["DEGRADED"] = "degraded";
+  Status2["DOWN"] = "down";
+  Status2["UNKNOWN"] = "unknown";
+  return Status2;
+})(Status || {});
+var CheckResult = class {
+  provider;
+  status;
+  statusDetail;
+  model;
+  alternatives;
+  constructor(init) {
+    this.provider = init.provider;
+    this.status = init.status;
+    this.statusDetail = init.statusDetail ?? null;
+    this.model = init.model ?? null;
+    this.alternatives = init.alternatives ?? [];
+  }
+  get isAvailable() {
+    return this.status === "operational" /* OPERATIONAL */;
+  }
+};
+var RouteResponse = class {
+  content;
+  modelUsed;
+  providerUsed;
+  wasFallback;
+  fallbackReason;
+  inputTokens;
+  outputTokens;
+  costUsd;
+  raw;
+  constructor(init) {
+    this.content = init.content;
+    this.modelUsed = init.modelUsed;
+    this.providerUsed = init.providerUsed;
+    this.wasFallback = init.wasFallback;
+    this.fallbackReason = init.fallbackReason ?? null;
+    this.inputTokens = init.inputTokens ?? 0;
+    this.outputTokens = init.outputTokens ?? 0;
+    this.costUsd = init.costUsd ?? 0;
+    this.raw = init.raw ?? null;
+  }
+  toString() {
+    return this.content;
+  }
+};
+
+// src/defaults.ts
+var AUTO_PROVIDERS = {
+  anthropic: {
+    envVar: "ANTHROPIC_API_KEY",
+    adapterType: "anthropic"
+  },
+  openai: {
+    envVar: "OPENAI_API_KEY",
+    adapterType: "openai"
+  },
+  google: {
+    envVar: "GEMINI_API_KEY",
+    adapterType: "google"
+  },
+  openrouter: {
+    envVar: "OPENROUTER_API_KEY",
+    adapterType: "openrouter"
+  },
+  deepseek: {
+    envVar: "DEEPSEEK_API_KEY",
+    adapterType: "deepseek"
+  },
+  mistral: {
+    envVar: "MISTRAL_API_KEY",
+    adapterType: "mistral",
+    aliases: ["mistralai"]
+  },
+  xai: {
+    envVar: "XAI_API_KEY",
+    adapterType: "xai",
+    aliases: ["x-ai"]
+  },
+  groq: {
+    envVar: "GROQ_API_KEY",
+    adapterType: "groq"
+  },
+  together: {
+    envVar: "TOGETHER_API_KEY",
+    adapterType: "together"
+  },
+  moonshot: {
+    envVar: "MOONSHOT_API_KEY",
+    adapterType: "moonshot",
+    aliases: ["moonshotai"]
+  },
+  qwen: {
+    envVar: "DASHSCOPE_API_KEY",
+    adapterType: "qwen"
+  }
+};
+var PROVIDER_ALIASES = {
+  anthropic: "anthropic",
+  openai: "openai",
+  google: "google",
+  openrouter: "openrouter",
+  deepseek: "deepseek",
+  mistral: "mistral",
+  mistralai: "mistral",
+  xai: "xai",
+  "x-ai": "xai",
+  groq: "groq",
+  together: "together",
+  moonshot: "moonshot",
+  moonshotai: "moonshot",
+  qwen: "qwen"
+};
+var MODEL_PREFIX_MAP = {
+  claude: "anthropic",
+  gpt: "openai",
+  o1: "openai",
+  o3: "openai",
+  o4: "openai",
+  chatgpt: "openai",
+  gemini: "google",
+  deepseek: "deepseek",
+  mistral: "mistral",
+  codestral: "mistral",
+  pixtral: "mistral",
+  grok: "xai",
+  llama: "groq",
+  qwen: "qwen",
+  moonshot: "moonshot"
+};
+function normalizeProviderSlug(slug) {
+  const value = (slug ?? "").trim().toLowerCase();
+  return PROVIDER_ALIASES[value] ?? value;
+}
+function extractProviderSlug(modelId) {
+  const value = (modelId ?? "").trim();
+  if (!value.includes("/")) {
+    return null;
+  }
+  return normalizeProviderSlug(value.split("/", 1)[0]);
+}
+
+// src/providers/base.ts
+var ProviderAdapter = class {
+  config;
+  constructor(config) {
+    this.config = {
+      ...config,
+      slug: normalizeProviderSlug(config.slug),
+      aliases: (config.aliases ?? []).map((alias) => normalizeProviderSlug(alias))
+    };
+  }
+  get slug() {
+    return this.config.slug;
+  }
+  get aliases() {
+    return this.config.aliases ?? [];
+  }
+  supportsProvider(slug) {
+    const normalized = normalizeProviderSlug(slug);
+    return normalized === this.slug || this.aliases.includes(normalized);
+  }
+  stripProvider(modelId) {
+    if (!modelId.includes("/")) {
+      return modelId;
+    }
+    return modelId.slice(modelId.indexOf("/") + 1);
+  }
+};
+var ADAPTER_TYPES = /* @__PURE__ */ new Map();
+function registerAdapterType(typeName, ctor) {
+  ADAPTER_TYPES.set(typeName.toLowerCase(), ctor);
+}
+function createAdapter(config) {
+  const ctor = ADAPTER_TYPES.get(config.adapterType.toLowerCase());
+  if (!ctor) {
+    throw new Error(`Unknown adapter type: ${config.adapterType}`);
+  }
+  return new ctor(config);
+}
+
+// src/providers/openai.ts
+var OpenAIAdapter = class extends ProviderAdapter {
+  defaultBaseUrl = "https://api.openai.com/v1";
+  defaultEnvVar = "OPENAI_API_KEY";
+  getBaseUrl() {
+    return this.config.baseUrl ?? this.defaultBaseUrl;
+  }
+  getApiKey() {
+    return requireApiKey(
+      this.slug,
+      this.config.apiKey ?? readEnv(this.config.env ?? this.defaultEnvVar),
+      this.config.env ?? this.defaultEnvVar
+    );
+  }
+  getDefaultHeaders() {
+    return {};
+  }
+  buildPayload(modelId, messages, options) {
+    const payload = {
+      ...options.providerOptions ?? {},
+      model: this.stripProvider(modelId),
+      messages
+    };
+    if (options.maxTokens !== void 0 && payload.max_tokens === void 0 && payload.max_completion_tokens === void 0) {
+      payload.max_tokens = options.maxTokens;
+    }
+    if (options.temperature !== void 0 && payload.temperature === void 0) {
+      payload.temperature = options.temperature;
+    }
+    if (options.topP !== void 0 && payload.top_p === void 0) {
+      payload.top_p = options.topP;
+    }
+    return payload;
+  }
+  async call(modelId, messages, timeoutSeconds, options) {
+    const response = await fetchJson(
+      joinUrl(this.getBaseUrl(), "chat/completions"),
+      {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${this.getApiKey()}`,
+          ...this.getDefaultHeaders(),
+          ...this.config.headers ?? {},
+          ...options.headers ?? {}
+        },
+        body: this.buildPayload(modelId, messages, options),
+        timeoutMs: timeoutSeconds * 1e3,
+        signal: options.signal
+      }
+    );
+    return this.toResponse(response, modelId);
+  }
+  toResponse(response, modelId) {
+    return new RouteResponse({
+      content: extractText(response.choices?.[0]?.message?.content),
+      modelUsed: modelId,
+      providerUsed: this.slug,
+      wasFallback: false,
+      inputTokens: response.usage?.prompt_tokens ?? 0,
+      outputTokens: response.usage?.completion_tokens ?? 0,
+      raw: response
+    });
+  }
+};
+registerAdapterType("openai", OpenAIAdapter);
+
+// src/providers/openrouter.ts
+var OpenRouterAdapter = class extends OpenAIAdapter {
+  defaultBaseUrl = "https://openrouter.ai/api/v1";
+  defaultEnvVar = "OPENROUTER_API_KEY";
+  getDefaultHeaders() {
+    return {
+      "HTTP-Referer": "https://aistatus.cc",
+      "X-Title": "aistatus"
+    };
+  }
+};
+registerAdapterType("openrouter", OpenRouterAdapter);
+
+// src/providers/anthropic.ts
+var AnthropicAdapter = class extends ProviderAdapter {
+  defaultBaseUrl = "https://api.anthropic.com/v1";
+  defaultEnvVar = "ANTHROPIC_API_KEY";
+  async call(modelId, messages, timeoutSeconds, options) {
+    const systemParts = [];
+    const anthropicMessages = messages.filter((message) => {
+      if (message.role === "system") {
+        systemParts.push(message.content);
+        return false;
+      }
+      return true;
+    }).map((message) => ({
+      role: message.role === "assistant" ? "assistant" : "user",
+      content: message.content
+    }));
+    const payload = {
+      ...options.providerOptions ?? {},
+      model: this.stripProvider(modelId),
+      messages: anthropicMessages
+    };
+    if (systemParts.length > 0 && payload.system === void 0) {
+      payload.system = systemParts.join("\n\n");
+    }
+    if (payload.max_tokens === void 0) {
+      payload.max_tokens = options.maxTokens ?? 4096;
+    }
+    if (options.temperature !== void 0 && payload.temperature === void 0) {
+      payload.temperature = options.temperature;
+    }
+    if (options.topP !== void 0 && payload.top_p === void 0) {
+      payload.top_p = options.topP;
+    }
+    const response = await fetchJson(
+      joinUrl(this.config.baseUrl ?? this.defaultBaseUrl, "messages"),
+      {
+        method: "POST",
+        headers: {
+          "x-api-key": requireApiKey(
+            this.slug,
+            this.config.apiKey ?? readEnv(this.config.env ?? this.defaultEnvVar),
+            this.config.env ?? this.defaultEnvVar
+          ),
+          "anthropic-version": "2023-06-01",
+          ...this.config.headers ?? {},
+          ...options.headers ?? {}
+        },
+        body: payload,
+        timeoutMs: timeoutSeconds * 1e3,
+        signal: options.signal
+      }
+    );
+    return new RouteResponse({
+      content: (response.content ?? []).filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join("\n"),
+      modelUsed: modelId,
+      providerUsed: this.slug,
+      wasFallback: false,
+      inputTokens: response.usage?.input_tokens ?? 0,
+      outputTokens: response.usage?.output_tokens ?? 0,
+      raw: response
+    });
+  }
+};
+registerAdapterType("anthropic", AnthropicAdapter);
+
+// src/providers/google.ts
+var GoogleAdapter = class extends ProviderAdapter {
+  defaultBaseUrl = "https://generativelanguage.googleapis.com/v1beta";
+  defaultEnvVar = "GEMINI_API_KEY";
+  async call(modelId, messages, timeoutSeconds, options) {
+    const providerOptions = { ...options.providerOptions ?? {} };
+    const generationConfig = isRecord(providerOptions.generationConfig) ? { ...providerOptions.generationConfig } : {};
+    const systemParts = [];
+    const contents = messages.filter((message) => {
+      if (message.role === "system") {
+        systemParts.push(message.content);
+        return false;
+      }
+      return true;
+    }).map((message) => ({
+      role: message.role === "assistant" ? "model" : "user",
+      parts: [{ text: message.content }]
+    }));
+    if (options.maxTokens !== void 0 && generationConfig.maxOutputTokens === void 0) {
+      generationConfig.maxOutputTokens = options.maxTokens;
+    }
+    if (options.temperature !== void 0 && generationConfig.temperature === void 0) {
+      generationConfig.temperature = options.temperature;
+    }
+    if (options.topP !== void 0 && generationConfig.topP === void 0) {
+      generationConfig.topP = options.topP;
+    }
+    const body = {
+      ...providerOptions,
+      contents
+    };
+    if (Object.keys(generationConfig).length > 0) {
+      body.generationConfig = generationConfig;
+    }
+    if (systemParts.length > 0 && body.systemInstruction === void 0) {
+      body.systemInstruction = {
+        parts: [{ text: systemParts.join("\n\n") }]
+      };
+    }
+    const modelName = normalizeGoogleModelName(this.stripProvider(modelId));
+    const apiKey = requireApiKey(
+      this.slug,
+      this.config.apiKey ?? readEnv(this.config.env ?? this.defaultEnvVar),
+      this.config.env ?? this.defaultEnvVar
+    );
+    const url = new URL(
+      `${this.config.baseUrl ?? this.defaultBaseUrl}/models/${modelName}:generateContent`
+    );
+    url.searchParams.set("key", apiKey);
+    const response = await fetchJson(url.toString(), {
+      method: "POST",
+      headers: {
+        ...this.config.headers ?? {},
+        ...options.headers ?? {}
+      },
+      body,
+      timeoutMs: timeoutSeconds * 1e3,
+      signal: options.signal
+    });
+    return new RouteResponse({
+      content: (response.candidates?.[0]?.content?.parts ?? []).map((part) => part.text ?? "").filter(Boolean).join("\n"),
+      modelUsed: modelId,
+      providerUsed: this.slug,
+      wasFallback: false,
+      inputTokens: response.usageMetadata?.promptTokenCount ?? 0,
+      outputTokens: response.usageMetadata?.candidatesTokenCount ?? 0,
+      raw: response
+    });
+  }
+};
+function normalizeGoogleModelName(modelName) {
+  return modelName.startsWith("models/") ? modelName.slice(7) : modelName;
+}
+registerAdapterType("google", GoogleAdapter);
+
+// src/providers/compatible.ts
+var DeepSeekAdapter = class extends OpenAIAdapter {
+  defaultBaseUrl = "https://api.deepseek.com";
+  defaultEnvVar = "DEEPSEEK_API_KEY";
+};
+var MistralAdapter = class extends OpenAIAdapter {
+  defaultBaseUrl = "https://api.mistral.ai/v1";
+  defaultEnvVar = "MISTRAL_API_KEY";
+};
+var XAIAdapter = class extends OpenAIAdapter {
+  defaultBaseUrl = "https://api.x.ai/v1";
+  defaultEnvVar = "XAI_API_KEY";
+};
+var GroqAdapter = class extends OpenAIAdapter {
+  defaultBaseUrl = "https://api.groq.com/openai/v1";
+  defaultEnvVar = "GROQ_API_KEY";
+};
+var TogetherAdapter = class extends OpenAIAdapter {
+  defaultBaseUrl = "https://api.together.xyz/v1";
+  defaultEnvVar = "TOGETHER_API_KEY";
+};
+var MoonshotAdapter = class extends OpenAIAdapter {
+  defaultBaseUrl = "https://api.moonshot.cn/v1";
+  defaultEnvVar = "MOONSHOT_API_KEY";
+};
+var QwenAdapter = class extends OpenAIAdapter {
+  defaultBaseUrl = "https://dashscope.aliyuncs.com/compatible-mode/v1";
+  defaultEnvVar = "DASHSCOPE_API_KEY";
+};
+registerAdapterType("deepseek", DeepSeekAdapter);
+registerAdapterType("mistral", MistralAdapter);
+registerAdapterType("xai", XAIAdapter);
+registerAdapterType("groq", GroqAdapter);
+registerAdapterType("together", TogetherAdapter);
+registerAdapterType("moonshot", MoonshotAdapter);
+registerAdapterType("qwen", QwenAdapter);
+
+// src/api.ts
+var BASE_URL = "https://aistatus.cc";
+var StatusAPI = class {
+  baseUrl;
+  timeoutMs;
+  constructor(baseUrl = BASE_URL, timeoutSeconds = 3) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.timeoutMs = timeoutSeconds * 1e3;
+  }
+  async checkProvider(slug) {
+    const data = await this.get("/api/check", {
+      provider: slug
+    });
+    return this.parseCheck(data);
+  }
+  async checkModel(modelId) {
+    const data = await this.get("/api/check", {
+      model: modelId
+    });
+    return this.parseCheck(data);
+  }
+  async acheckProvider(slug) {
+    return this.checkProvider(slug);
+  }
+  async acheckModel(modelId) {
+    return this.checkModel(modelId);
+  }
+  async providers() {
+    const data = await this.get("/api/providers");
+    const providers = Array.isArray(data.providers) ? data.providers : [];
+    return providers.map((provider) => this.parseProviderStatus(provider)).filter((provider) => provider !== null);
+  }
+  async model(modelId) {
+    try {
+      const data = await this.get(`/api/models/${encodeURI(modelId)}`);
+      return this.parseModel(data);
+    } catch (error) {
+      if (error instanceof HTTPStatusError && error.status === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async searchModels(query) {
+    const data = await this.get("/api/models", {
+      q: query
+    });
+    const models = Array.isArray(data.models) ? data.models : [];
+    return models.map((model) => this.parseModel(model)).filter((model) => model !== null);
+  }
+  async get(path, params) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0) {
+          url.searchParams.set(key, value);
+        }
+      }
+    }
+    return fetchJson(url.toString(), {
+      timeoutMs: this.timeoutMs
+    });
+  }
+  parseCheck(data) {
+    const model = asString(data.model) ?? null;
+    const provider = normalizeProviderSlug(
+      asString(data.provider) ?? asString(data.slug) ?? extractProviderSlug(model) ?? ""
+    ) || "";
+    const status = parseStatus(
+      asString(data.status) ?? asString(data.providerStatus) ?? availableToStatus(data.available)
+    );
+    const alternatives = Array.isArray(data.alternatives) ? data.alternatives.map((alternative) => parseAlternative(alternative)).filter((alternative) => alternative !== null) : [];
+    return new CheckResult({
+      provider,
+      status,
+      statusDetail: asString(data.statusDetail) ?? asString(data.providerStatusDetail) ?? null,
+      model,
+      alternatives
+    });
+  }
+  parseProviderStatus(value) {
+    if (!isRecord(value)) {
+      return null;
+    }
+    return {
+      slug: normalizeProviderSlug(asString(value.slug) ?? ""),
+      name: asString(value.name) ?? asString(value.slug) ?? "",
+      status: parseStatus(asString(value.status)),
+      statusDetail: asString(value.statusDetail) ?? null,
+      modelCount: asNumber(value.modelCount)
+    };
+  }
+  parseModel(value) {
+    if (!isRecord(value)) {
+      return null;
+    }
+    const pricing = isRecord(value.pricing) ? value.pricing : {};
+    const provider = isRecord(value.provider) ? value.provider : {};
+    return {
+      id: asString(value.id) ?? "",
+      name: asString(value.name) ?? "",
+      providerSlug: normalizeProviderSlug(
+        asString(provider.slug) ?? extractProviderSlug(asString(value.id) ?? "") ?? ""
+      ),
+      contextLength: asNumber(value.context_length),
+      modality: asString(value.modality) ?? "text->text",
+      promptPrice: asFloat(pricing.prompt),
+      completionPrice: asFloat(pricing.completion)
+    };
+  }
+};
+function parseAlternative(value) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const suggestedModel = asString(value.suggestedModel) ?? asString(value.model) ?? asString(value.id) ?? "";
+  const slug = normalizeProviderSlug(
+    asString(value.slug) ?? asString(value.provider) ?? extractProviderSlug(suggestedModel) ?? ""
+  );
+  return {
+    slug,
+    name: asString(value.name) ?? slug,
+    status: parseStatus(
+      asString(value.status) ?? asString(value.providerStatus) ?? availableToStatus(value.available)
+    ),
+    suggestedModel
+  };
+}
+function availableToStatus(value) {
+  if (value === true) {
+    return "operational" /* OPERATIONAL */;
+  }
+  if (value === false) {
+    return "down" /* DOWN */;
+  }
+  return void 0;
+}
+function parseStatus(value) {
+  switch (value) {
+    case "operational" /* OPERATIONAL */:
+      return "operational" /* OPERATIONAL */;
+    case "degraded" /* DEGRADED */:
+      return "degraded" /* DEGRADED */;
+    case "down" /* DOWN */:
+      return "down" /* DOWN */;
+    default:
+      return "unknown" /* UNKNOWN */;
+  }
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+  return 0;
+}
+function asFloat(value) {
+  return asNumber(value);
+}
+
+// src/router.ts
+var Router = class {
+  api;
+  adapters = /* @__PURE__ */ new Map();
+  adapterIndex = /* @__PURE__ */ new Map();
+  tiers = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.api = new StatusAPI(
+      options.baseUrl,
+      options.checkTimeout ?? 3
+    );
+    if (options.autoDiscover !== false) {
+      this.autoDiscover(options.providers);
+    }
+  }
+  registerProvider(config) {
+    const adapter = createAdapter(config);
+    this.adapters.set(adapter.slug, adapter);
+    this.indexAdapter(adapter);
+  }
+  addTier(name, models) {
+    this.tiers.set(name, [...models]);
+  }
+  async route(messages, options = {}) {
+    const normalizedMessages = this.normalizeMessages(messages, options.system);
+    const callOptions = this.extractCallOptions(options);
+    if (!options.model && !options.tier) {
+      throw new Error("Either 'model' or 'tier' must be specified");
+    }
+    if (options.tier) {
+      return this.routeTier(normalizedMessages, options.tier, options, callOptions);
+    }
+    return this.routeModel(
+      normalizedMessages,
+      options.model,
+      options,
+      callOptions
+    );
+  }
+  async aroute(messages, options = {}) {
+    return this.route(messages, options);
+  }
+  autoDiscover(only) {
+    for (const [slug, spec] of Object.entries(AUTO_PROVIDERS)) {
+      if (only && !only.includes(slug)) {
+        continue;
+      }
+      if (!readEnv(spec.envVar)) {
+        continue;
+      }
+      this.registerProvider({
+        slug,
+        adapterType: spec.adapterType,
+        env: spec.envVar,
+        aliases: spec.aliases
+      });
+    }
+  }
+  indexAdapter(adapter) {
+    this.adapterIndex.set(adapter.slug, adapter.slug);
+    for (const alias of adapter.aliases) {
+      this.adapterIndex.set(alias, adapter.slug);
+    }
+  }
+  normalizeMessages(messages, system) {
+    const normalized = typeof messages === "string" ? [{ role: "user", content: messages }] : [...messages];
+    if (system) {
+      normalized.unshift({ role: "system", content: system });
+    }
+    return normalized;
+  }
+  extractCallOptions(options) {
+    const {
+      model: _model,
+      tier: _tier,
+      system: _system,
+      allowFallback: _allowFallback,
+      timeout: _timeout,
+      prefer: _prefer,
+      maxTokens,
+      temperature,
+      topP,
+      providerOptions,
+      headers,
+      signal,
+      ...extraProviderOptions
+    } = options;
+    return {
+      maxTokens,
+      temperature,
+      topP,
+      providerOptions: {
+        ...extraProviderOptions,
+        ...providerOptions ?? {}
+      },
+      headers,
+      signal
+    };
+  }
+  async resolveModel(model, prefer) {
+    try {
+      const check = await this.api.checkModel(model);
+      const primaryProvider = check.provider || this.guessProvider(model)[0]?.providerSlug;
+      const primary = {
+        providerSlug: primaryProvider,
+        modelId: check.model ?? model
+      };
+      const alternatives = check.alternatives.filter((alternative) => alternative.status === "operational").map((alternative) => ({
+        providerSlug: alternative.slug,
+        modelId: alternative.suggestedModel || model
+      }));
+      const ordered = check.isAvailable ? [primary, ...alternatives] : [...alternatives, primary];
+      return this.sortAndBindCandidates(ordered, prefer);
+    } catch {
+      return this.sortAndBindCandidates(this.guessProvider(model), prefer);
+    }
+  }
+  guessProvider(model) {
+    const normalizedModel = model.toLowerCase();
+    const directProvider = normalizeProviderSlug(model.split("/", 1)[0]);
+    if (model.includes("/") && this.adapterIndex.has(directProvider)) {
+      return [{ providerSlug: directProvider, modelId: model }];
+    }
+    for (const [prefix, providerSlug] of Object.entries(MODEL_PREFIX_MAP)) {
+      if (normalizedModel.startsWith(prefix)) {
+        return [{ providerSlug, modelId: model }];
+      }
+    }
+    return Array.from(this.adapters.keys()).map((adapterKey) => ({
+      providerSlug: adapterKey,
+      modelId: model
+    }));
+  }
+  sortAndBindCandidates(candidates, prefer) {
+    const preferOrder = (prefer ?? []).map((item) => normalizeProviderSlug(item));
+    const resolved = candidates.map((candidate) => {
+      const providerSlug = normalizeProviderSlug(candidate.providerSlug);
+      const adapterKey = this.adapterIndex.get(providerSlug);
+      if (!adapterKey) {
+        return null;
+      }
+      return {
+        providerSlug,
+        adapterKey,
+        modelId: candidate.modelId
+      };
+    }).filter((candidate) => candidate !== null);
+    resolved.sort((left, right) => {
+      if (preferOrder.length === 0) {
+        return 0;
+      }
+      return preferenceScore(left, preferOrder) - preferenceScore(right, preferOrder);
+    });
+    return dedupeCandidates(resolved);
+  }
+  async routeModel(messages, model, options, callOptions) {
+    const candidates = await this.resolveModel(model, options.prefer);
+    if (candidates.length === 0) {
+      throw new AllProvidersDown([`no adapter for model '${model}'`]);
+    }
+    const tried = [];
+    const first = candidates[0];
+    for (const candidate of candidates) {
+      const adapter = this.adapters.get(candidate.adapterKey);
+      if (!adapter) {
+        continue;
+      }
+      try {
+        const response = await adapter.call(
+          candidate.modelId,
+          messages,
+          options.timeout ?? 30,
+          callOptions
+        );
+        const usedModel = response.modelUsed.includes("/") ? response.modelUsed : `${candidate.providerSlug}/${response.modelUsed}`;
+        const isFallback = candidate.providerSlug !== first.providerSlug || candidate.modelId !== first.modelId;
+        return new RouteResponse({
+          content: response.content,
+          modelUsed: usedModel,
+          providerUsed: candidate.providerSlug,
+          wasFallback: isFallback,
+          fallbackReason: isFallback ? `${first.providerSlug} unavailable` : null,
+          inputTokens: response.inputTokens,
+          outputTokens: response.outputTokens,
+          costUsd: response.costUsd,
+          raw: response.raw
+        });
+      } catch (error) {
+        tried.push(`${candidate.providerSlug}[error]`);
+        if (options.allowFallback === false) {
+          throw new ProviderCallFailed(
+            candidate.providerSlug,
+            candidate.modelId,
+            error
+          );
+        }
+      }
+    }
+    throw new AllProvidersDown(tried);
+  }
+  async routeTier(messages, tier, options, callOptions) {
+    const models = this.tiers.get(tier);
+    if (!models) {
+      throw new Error(
+        `Tier '${tier}' not configured. Use router.addTier('${tier}', ['model-a']) first.`
+      );
+    }
+    const tried = [];
+    for (const model of models) {
+      try {
+        return await this.routeModel(messages, model, options, callOptions);
+      } catch (error) {
+        if (error instanceof AllProvidersDown) {
+          tried.push(...error.tried);
+          continue;
+        }
+        if (error instanceof ProviderCallFailed && options.allowFallback === false) {
+          throw error;
+        }
+      }
+    }
+    throw new AllProvidersDown(tried);
+  }
+};
+function preferenceScore(candidate, preferOrder) {
+  const providerIndex = preferOrder.indexOf(candidate.providerSlug);
+  if (providerIndex !== -1) {
+    return providerIndex;
+  }
+  const adapterIndex = preferOrder.indexOf(candidate.adapterKey);
+  if (adapterIndex !== -1) {
+    return adapterIndex;
+  }
+  return preferOrder.length;
+}
+function dedupeCandidates(candidates) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const candidate of candidates) {
+    const key = `${candidate.adapterKey}:${candidate.modelId}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    result.push(candidate);
+  }
+  return result;
+}
+
+// src/index.ts
+var VERSION = "0.0.2";
+var defaultRouter = null;
+function getDefaultRouter() {
+  defaultRouter ??= new Router();
+  return defaultRouter;
+}
+async function route(messages, options = {}) {
+  return getDefaultRouter().route(messages, options);
+}
+async function aroute(messages, options = {}) {
+  return route(messages, options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AIStatusError,
+  AllProvidersDown,
+  CheckAPIUnreachable,
+  CheckResult,
+  NoBudgetMatch,
+  ProviderAdapter,
+  ProviderCallFailed,
+  ProviderNotConfigured,
+  ProviderNotInstalled,
+  RouteResponse,
+  Router,
+  Status,
+  StatusAPI,
+  VERSION,
+  aroute,
+  createAdapter,
+  registerAdapterType,
+  route
+});