@sahan-sac/ai-core 0.2.0 → 0.3.0

package/dist/providers.d.ts

@@ -32,6 +32,12 @@ interface AiProvider {
     readonly name: string;
     /** Paid or otherwise costly: tried only after every other provider, whatever its speed or health. */
     readonly lastResort?: boolean;
+    /**
+     * Position in an order the operator chose (AI_PROVIDER_ORDER): lower goes
+     * first, and speed no longer reorders it. A cooling provider still drops
+     * behind the healthy ones.
+     */
+    readonly priority?: number;
     generate(prompt: ModelPrompt, options?: AiGenerateOptions): Promise<AiOutcome>;
 }
 interface AiAttempt {
@@ -106,6 +112,13 @@ declare function createAiService(deps: AiServiceDeps): {
          * (malformed JSON from a weak model) from beating a slower valid one.
          */
         accept?: (text: string) => string | null;
+        /**
+         * The caller gave up (an admin cancelled, a client disconnected): every
+         * running attempt is aborted, no further provider starts, and the result
+         * is `errorClass: "aborted"`. An aborted attempt is not the provider's
+         * fault, so it is neither logged nor cooled down.
+         */
+        signal?: AbortSignal;
     }) => Promise<AiResult>;
 };
 /** OpenRouter, OpenAI-compatible. Refuses a paid model id unless the owner opted in. */
@@ -117,12 +130,33 @@ declare function openRouterProvider(config: {
     fetch?: typeof fetch;
     name?: string;
 }): AiProvider;
+/**
+ * Any OpenAI-compatible chat completions API: OpenAI itself, DeepSeek, xAI
+ * (Grok), Perplexity, a self-hosted gateway (vLLM, Ollama, LiteLLM).
+ */
+declare function openAiCompatibleProvider(config: {
+    name: string;
+    apiKey: string;
+    baseUrl: string;
+    model: string;
+    headers?: Record<string, string>;
+    fetch?: typeof fetch;
+}): AiProvider;
 /** NVIDIA NIM, OpenAI-compatible. */
 declare function nvidiaProvider(config: {
     apiKey: string;
     model?: string;
     fetch?: typeof fetch;
 }): AiProvider;
+/** Text of an Anthropic Messages reply; a reply stopped at the token cap is "truncated", a refusal "refused". */
+declare function anthropicOutcome(data: unknown): AiOutcome;
+/** Anthropic's Messages API over plain REST (no extra SDK for one provider). */
+declare function anthropicProvider(config: {
+    apiKey: string;
+    model: string;
+    baseUrl?: string;
+    fetchImpl?: typeof fetch;
+}): AiProvider;
 /** Text of a Gemini/Vertex generateContent reply; a reply stopped at the token cap is "truncated", not a success. */
 declare function geminiOutcome(data: unknown): AiOutcome;
 /** Gemini's own REST API (not OpenAI-compatible), called directly so no extra SDK is added for one provider. */
@@ -144,14 +178,116 @@ declare function vertexProvider(config: {
     model?: string;
     fetchImpl?: typeof fetch;
 }): AiProvider;
+
+interface AdapterContext {
+    env: AiEnv;
+    purpose: TextPurpose;
+    fetch?: typeof fetch;
+}
+interface ProviderAdapter {
+    /** Lowercase id used in AI_PROVIDER_ORDER. */
+    readonly id: string;
+    readonly label: string;
+    /** Costs money: runs only with AI_ALLOW_PAID. */
+    paid(env: AiEnv): boolean;
+    /** Env variable names still missing; empty means configured. Never values. */
+    missing(env: AiEnv): string[];
+    create(context: AdapterContext): AiProvider;
+}
+/**
+ * Defaults for the paid adapters. Model names change often: set the
+ * provider's *_MODEL variable rather than relying on these.
+ */
+declare const PAID_TEXT_MODELS: {
+    readonly openai: {
+        readonly blog: "gpt-5-mini";
+        readonly chat: "gpt-5-nano";
+    };
+    readonly anthropic: {
+        readonly blog: "claude-sonnet-5-5";
+        readonly chat: "claude-haiku-4-5-20251001";
+    };
+    readonly deepseek: {
+        readonly blog: "deepseek-chat";
+        readonly chat: "deepseek-chat";
+    };
+    readonly xai: {
+        readonly blog: "grok-3-mini";
+        readonly chat: "grok-3-mini";
+    };
+    readonly perplexity: {
+        readonly blog: "sonar";
+        readonly chat: "sonar";
+    };
+};
+declare const BUILTIN_ADAPTERS: readonly ProviderAdapter[];
+/** Free tiers first (fastest, most reliable first), paid last. */
+declare const DEFAULT_ORDER: string[];
+/** The order variable that applies to a purpose, parsed: lowercase ids, no repeats. Null when unset. */
+declare function configuredOrder(env: AiEnv, purpose: TextPurpose): string[] | null;
+type AdapterState = "active" | "not_configured" | "needs_paid" | "not_in_order" | "unknown";
+interface AdapterStatus {
+    id: string;
+    label: string;
+    paid: boolean;
+    state: AdapterState;
+    /** Position in the chain (0 first) when active. */
+    position?: number;
+    /** Missing variable names when not configured. */
+    missing: string[];
+}
+/** Every adapter's place for a purpose: in the chain or why not. Pure, no network; for health screens. */
+declare function providerStatuses(env: AiEnv, purpose: TextPurpose, adapters?: readonly ProviderAdapter[]): AdapterStatus[];
+/** The adapters that run for a purpose, in order, without building anything. */
+declare function chainPlan(env: AiEnv, purpose: TextPurpose, adapters?: readonly ProviderAdapter[]): ProviderAdapter[];
+/** The prompt a manual check sends: one word back, a few tokens at most. */
+declare const CHECK_PROMPT: {
+    readonly system: "You are a connectivity check. Reply with the single word OK.";
+    readonly user: "Reply with OK.";
+};
+interface ProviderCheck {
+    id: string;
+    ok: boolean;
+    /** Provider name that answered (for a chain check, the one that won). */
+    provider?: string;
+    errorClass?: string;
+    ms: number;
+    /** Every provider tried, for a chain check. */
+    attempts?: Array<{
+        provider: string;
+        ok: boolean;
+        errorClass?: string;
+    }>;
+}
+/**
+ * Sends CHECK_PROMPT through one adapter, whatever the chain order or
+ * AI_ALLOW_PAID says: an operator asked for it, and it spends a few tokens.
+ * Never throws; a missing variable answers `not_configured` without a call.
+ */
+declare function checkProvider(env: AiEnv, id: string, options?: {
+    purpose?: TextPurpose;
+    fetch?: typeof fetch;
+    timeoutMs?: number;
+    adapters?: readonly ProviderAdapter[];
+    now?: () => number;
+}): Promise<ProviderCheck>;
+/**
+ * Sends CHECK_PROMPT through a purpose's whole chain, the same way a real
+ * request goes: the first provider that answers wins, and `attempts` shows
+ * every provider that failed before it. A fresh health record, so a check
+ * never cools down a provider for real traffic.
+ */
+declare function checkChain(env: AiEnv, purpose: TextPurpose, options?: {
+    fetch?: typeof fetch;
+    deadlineMs?: number;
+    adapters?: readonly ProviderAdapter[];
+    now?: () => number;
+}): Promise<ProviderCheck>;
 /**
- * The chain from decision D15, free tiers first and paid last:
- * 1. Gemini (free API key, fast)
- * 2. OpenRouter (free-tier models, heavily rate-limited)
- * 3. NVIDIA (free developer API; key may be dead or model retired)
- * 4. Vertex (pay-as-you-go): only with AI_ALLOW_PAID, and only after the free ones
- * Models per purpose come from lib/ai/models.ts (env override, else a verified free default).
+ * The provider chain for a purpose. Pass `adapters` to add your own (for
+ * example `[...BUILTIN_ADAPTERS, myAdapter]`) and list its id in
+ * AI_PROVIDER_ORDER, or rely on the default order (built-ins, then yours).
  */
-declare function realProviders(env: AiEnv, purpose: TextPurpose, fetchImpl?: typeof fetch): AiProvider[];
+declare function realProviders(env: AiEnv, purpose: TextPurpose, fetchImpl?: typeof fetch, adapters?: readonly ProviderAdapter[]): AiProvider[];
 
-export { AI_COOLDOWN_MS, AI_TIMEOUT_MS, type AiAttempt, type AiAttemptStatus, type AiGenerateOptions, type AiHealth, type AiOutcome, type AiProvider, type AiResult, type AiServiceDeps, HEDGE, type JsonMode, createAiHealth, createAiService, geminiOutcome, geminiProvider, nvidiaProvider, openRouterProvider, realProviders, sharedAiHealth, vertexProvider };
+export { type AdapterContext as A, AI_COOLDOWN_MS, AI_TIMEOUT_MS, type AiAttempt, type AiAttemptStatus, type AiGenerateOptions, type AiHealth, type AiOutcome, type AiProvider, type AiResult, type AiServiceDeps, BUILTIN_ADAPTERS as B, CHECK_PROMPT as C, DEFAULT_ORDER as D, HEDGE, type JsonMode, PAID_TEXT_MODELS as P, type AdapterState as a, anthropicOutcome, anthropicProvider, type AdapterStatus as b, type ProviderAdapter as c, createAiHealth, createAiService, type ProviderCheck as d, chainPlan as e, checkChain as f, checkProvider as g, geminiOutcome, geminiProvider, configuredOrder as h, nvidiaProvider, openAiCompatibleProvider, openRouterProvider, providerStatuses as p, realProviders, sharedAiHealth, vertexProvider };

package/dist/providers.js

@@ -91,6 +91,160 @@ async function getVertexAccessToken(account, fetchImpl = fetch) {
   return data.access_token;
 }
 
+// src/adapters.ts
+function modelFor(env, provider, purpose, fallback) {
+  const record = env;
+  return record[`${purpose.toUpperCase()}_${provider}_MODEL`] || record[`${provider}_MODEL`] || fallback[purpose];
+}
+var need = (env, ...names) => names.filter((name) => !env[name]);
+var PAID_TEXT_MODELS = {
+  openai: { blog: "gpt-5-mini", chat: "gpt-5-nano" },
+  anthropic: { blog: "claude-sonnet-5-5", chat: "claude-haiku-4-5-20251001" },
+  deepseek: { blog: "deepseek-chat", chat: "deepseek-chat" },
+  xai: { blog: "grok-3-mini", chat: "grok-3-mini" },
+  perplexity: { blog: "sonar", chat: "sonar" }
+};
+function compatibleAdapter(spec) {
+  return {
+    id: spec.id,
+    label: spec.label,
+    paid: () => true,
+    missing: (env) => need(env, spec.keyVar),
+    create: ({ env, purpose, fetch: fetch2 }) => openAiCompatibleProvider({
+      name: spec.id,
+      apiKey: env[spec.keyVar],
+      baseUrl: spec.baseUrlVar && env[spec.baseUrlVar] || spec.baseUrl,
+      model: modelFor(env, spec.envPrefix, purpose, PAID_TEXT_MODELS[spec.id]),
+      fetch: fetch2
+    })
+  };
+}
+var openRouterAdapter = (id, keyVar) => ({
+  id,
+  label: id === "openrouter" ? "OpenRouter" : "OpenRouter (second key)",
+  // Free models only, unless OPENROUTER_ALLOW_PAID_MODELS: the adapter itself refuses a paid model id.
+  paid: () => false,
+  missing: (env) => need(env, keyVar),
+  create: ({ env, purpose, fetch: fetch2 }) => openRouterProvider({
+    apiKey: env[keyVar],
+    model: textModels(env, purpose).openrouter,
+    baseUrl: env.OPENROUTER_BASE_URL,
+    allowPaidModels: env.OPENROUTER_ALLOW_PAID_MODELS,
+    fetch: fetch2,
+    name: id
+  })
+});
+var BUILTIN_ADAPTERS = [
+  {
+    id: "gemini",
+    label: "Gemini",
+    paid: () => false,
+    missing: (env) => need(env, "GEMINI_API_KEY"),
+    create: ({ env, purpose, fetch: fetch2 }) => geminiProvider({ apiKey: env.GEMINI_API_KEY, model: textModels(env, purpose).gemini, fetchImpl: fetch2 })
+  },
+  openRouterAdapter("openrouter", "OPENROUTER_API_KEY"),
+  openRouterAdapter("openrouter-2", "OPENROUTER_API_KEY_2"),
+  {
+    id: "nvidia",
+    label: "NVIDIA",
+    paid: () => false,
+    missing: (env) => need(env, "NVIDIA_API_KEY"),
+    create: ({ env, purpose, fetch: fetch2 }) => openAiCompatibleProvider({
+      name: "nvidia",
+      apiKey: env.NVIDIA_API_KEY,
+      baseUrl: "https://integrate.api.nvidia.com/v1",
+      model: textModels(env, purpose).nvidia,
+      fetch: fetch2
+    })
+  },
+  compatibleAdapter({ id: "openai", label: "OpenAI", envPrefix: "OPENAI", keyVar: "OPENAI_API_KEY", baseUrl: "https://api.openai.com/v1", baseUrlVar: "OPENAI_BASE_URL" }),
+  {
+    id: "anthropic",
+    label: "Anthropic (Claude)",
+    paid: () => true,
+    missing: (env) => need(env, "ANTHROPIC_API_KEY"),
+    create: ({ env, purpose, fetch: fetch2 }) => anthropicProvider({
+      apiKey: env.ANTHROPIC_API_KEY,
+      baseUrl: env.ANTHROPIC_BASE_URL,
+      model: modelFor(env, "ANTHROPIC", purpose, PAID_TEXT_MODELS.anthropic),
+      fetchImpl: fetch2
+    })
+  },
+  compatibleAdapter({ id: "deepseek", label: "DeepSeek", envPrefix: "DEEPSEEK", keyVar: "DEEPSEEK_API_KEY", baseUrl: "https://api.deepseek.com/v1" }),
+  compatibleAdapter({ id: "xai", label: "xAI (Grok)", envPrefix: "XAI", keyVar: "XAI_API_KEY", baseUrl: "https://api.x.ai/v1" }),
+  compatibleAdapter({ id: "perplexity", label: "Perplexity", envPrefix: "PERPLEXITY", keyVar: "PERPLEXITY_API_KEY", baseUrl: "https://api.perplexity.ai" }),
+  {
+    id: "custom",
+    label: "Custom OpenAI-compatible",
+    paid: (env) => !env.AI_CUSTOM_FREE,
+    missing: (env) => need(env, "AI_CUSTOM_BASE_URL", "AI_CUSTOM_MODEL"),
+    create: ({ env, fetch: fetch2 }) => openAiCompatibleProvider({
+      name: env.AI_CUSTOM_NAME ? `custom:${env.AI_CUSTOM_NAME}` : "custom",
+      // A local server may take no key; the header must still be well formed.
+      apiKey: env.AI_CUSTOM_API_KEY ?? "none",
+      baseUrl: env.AI_CUSTOM_BASE_URL,
+      model: env.AI_CUSTOM_MODEL,
+      fetch: fetch2
+    })
+  },
+  {
+    id: "vertex",
+    label: "Vertex AI",
+    paid: () => true,
+    missing: (env) => vertexConfigured(env) ? [] : need(env, "GOOGLE_CLIENT_EMAIL", "GOOGLE_PRIVATE_KEY", "GOOGLE_CLOUD_PROJECT"),
+    create: ({ env, purpose, fetch: fetch2 }) => vertexProvider({
+      clientEmail: env.GOOGLE_CLIENT_EMAIL,
+      privateKey: env.GOOGLE_PRIVATE_KEY,
+      tokenUri: env.GOOGLE_TOKEN_URI,
+      project: env.GOOGLE_CLOUD_PROJECT,
+      model: textModels(env, purpose).vertex,
+      fetchImpl: fetch2
+    })
+  }
+];
+var DEFAULT_ORDER = BUILTIN_ADAPTERS.map((adapter) => adapter.id);
+function configuredOrder(env, purpose) {
+  const raw = (purpose === "blog" ? env.AI_PROVIDER_ORDER_BLOG : env.AI_PROVIDER_ORDER_CHAT) ?? env.AI_PROVIDER_ORDER;
+  if (!raw) return null;
+  const ids = raw.split(",").map((id) => id.trim().toLowerCase()).filter(Boolean);
+  return ids.length ? [...new Set(ids)] : null;
+}
+function providerStatuses(env, purpose, adapters = BUILTIN_ADAPTERS) {
+  const order = configuredOrder(env, purpose);
+  const ids = order ?? adapters.map((adapter) => adapter.id);
+  const byId = new Map(adapters.map((adapter) => [adapter.id, adapter]));
+  let position = 0;
+  const statuses = [];
+  for (const id of ids) {
+    const adapter = byId.get(id);
+    if (!adapter) {
+      statuses.push({ id, label: id, paid: false, state: "unknown", missing: [] });
+      continue;
+    }
+    const missing = adapter.missing(env);
+    const paid = adapter.paid(env);
+    const state = missing.length ? "not_configured" : paid && !paidAllowed(env) ? "needs_paid" : "active";
+    statuses.push({ id, label: adapter.label, paid, state, missing, ...state === "active" ? { position: position++ } : {} });
+  }
+  for (const adapter of adapters) {
+    if (!ids.includes(adapter.id)) {
+      statuses.push({ id: adapter.id, label: adapter.label, paid: adapter.paid(env), state: "not_in_order", missing: adapter.missing(env) });
+    }
+  }
+  return statuses;
+}
+function chainPlan(env, purpose, adapters = BUILTIN_ADAPTERS) {
+  const byId = new Map(adapters.map((adapter) => [adapter.id, adapter]));
+  return providerStatuses(env, purpose, adapters).filter((status) => status.state === "active").map((status) => byId.get(status.id));
+}
+function realProviders(env, purpose, fetchImpl, adapters = BUILTIN_ADAPTERS) {
+  const explicit = configuredOrder(env, purpose) !== null;
+  return chainPlan(env, purpose, adapters).map((adapter, index) => {
+    const provider = adapter.create({ env, purpose, fetch: fetchImpl });
+    return explicit ? { name: provider.name, generate: provider.generate, priority: index } : { name: provider.name, generate: provider.generate, lastResort: adapter.paid(env) || provider.lastResort };
+  });
+}
+
 // src/providers.ts
 function jsonConfig(jsonMode) {
   if (!jsonMode) return {};
@@ -136,12 +290,15 @@ function createAiService(deps) {
     const cooling = (p) => Number((health.cooldownUntil.get(p.name) ?? 0) > at);
     const speed = (p) => health.latencyMs.get(p.name) ?? Number.POSITIVE_INFINITY;
     const costly = (p) => Number(Boolean(p.lastResort));
-    return [...deps.providers].sort((a, b) => costly(a) - costly(b) || cooling(a) - cooling(b) || speed(a) - speed(b));
+    const chosen = (a, b) => a.priority !== void 0 && b.priority !== void 0 ? a.priority - b.priority : speed(a) - speed(b);
+    return [...deps.providers].sort((a, b) => costly(a) - costly(b) || cooling(a) - cooling(b) || chosen(a, b));
   }
   async function generate(prompt, options) {
     if (deps.providers.length === 0) {
       return { ok: false, provider: null, errorClass: "no_provider", attempts: [] };
     }
+    const external = options?.signal;
+    if (external?.aborted) return { ok: false, provider: null, errorClass: "aborted", attempts: [] };
     const startedAll = now();
     const ordered = rank(startedAll);
     const attempts = [];
@@ -151,6 +308,15 @@ function createAiService(deps) {
     let stopped = false;
     let result = null;
     let rejected;
+    let onAbort;
+    const aborted = new Promise((resolve) => {
+      onAbort = () => {
+        stopped = true;
+        cancelLosers.abort();
+        resolve();
+      };
+      external?.addEventListener("abort", onAbort, { once: true });
+    });
     const launch = () => {
       if (result || stopped || next >= ordered.length) return false;
       const remaining = deps.deadlineMs === void 0 ? timeoutMs : deps.deadlineMs - (now() - startedAll);
@@ -159,7 +325,7 @@ function createAiService(deps) {
       options?.onAttempt?.({ provider: provider.name, stage: "start" });
       const started = now();
       const run = attempt(provider, prompt, options?.maxTokens, Math.min(timeoutMs, remaining), cancelLosers.signal, options?.jsonMode).then((raw) => {
-        if (result) return;
+        if (result || external?.aborted) return;
         const ms = now() - started;
         let outcome = raw;
         if (outcome.ok && options?.accept) {
@@ -201,18 +367,24 @@ function createAiService(deps) {
       running.add(tracked);
       return true;
     };
-    while (!result) {
-      if (running.size === 0 && !launch()) break;
-      let timer;
-      const racers = [...running];
-      if (deps.hedgeAfterMs !== void 0 && next < ordered.length) {
-        racers.push(new Promise((resolve) => timer = setTimeout(() => resolve(HEDGE), deps.hedgeAfterMs)));
+    try {
+      while (!result && !external?.aborted) {
+        if (running.size === 0 && !launch()) break;
+        let timer;
+        const racers = [...running, aborted];
+        if (deps.hedgeAfterMs !== void 0 && next < ordered.length) {
+          racers.push(new Promise((resolve) => timer = setTimeout(() => resolve(HEDGE), deps.hedgeAfterMs)));
+        }
+        const first = await Promise.race(racers);
+        clearTimeout(timer);
+        if (first === HEDGE) launch();
       }
-      const first = await Promise.race(racers);
-      clearTimeout(timer);
-      if (first === HEDGE) launch();
+    } finally {
+      if (onAbort) external?.removeEventListener("abort", onAbort);
     }
-    return result ?? { ok: false, provider: null, errorClass: attempts[attempts.length - 1]?.errorClass ?? "deadline", attempts, rejected };
+    if (result) return result;
+    if (external?.aborted) return { ok: false, provider: null, errorClass: "aborted", attempts, rejected };
+    return { ok: false, provider: null, errorClass: attempts[attempts.length - 1]?.errorClass ?? "deadline", attempts, rejected };
   }
   return { generate };
 }
@@ -256,16 +428,57 @@ async function sdkGenerate(model, prompt, options) {
     return { ok: false, errorClass: options?.signal?.aborted ? "timeout" : "provider_error", retryable: true };
   }
 }
+function openAiCompatibleProvider(config) {
+  const client = createOpenAI({ apiKey: config.apiKey, baseURL: config.baseUrl, headers: config.headers, fetch: config.fetch });
+  return {
+    name: config.name,
+    generate: (prompt, options) => sdkGenerate(client.chat(config.model), prompt, options)
+  };
+}
 function nvidiaProvider(config) {
-  const model = config.model || DEFAULT_TEXT_MODELS.blog.nvidia;
-  const client = createOpenAI({
+  return openAiCompatibleProvider({
+    name: "nvidia",
     apiKey: config.apiKey,
-    baseURL: "https://integrate.api.nvidia.com/v1",
+    baseUrl: "https://integrate.api.nvidia.com/v1",
+    model: config.model || DEFAULT_TEXT_MODELS.blog.nvidia,
     fetch: config.fetch
   });
+}
+function anthropicOutcome(data) {
+  const reply = data;
+  if (reply.stop_reason === "max_tokens") return { ok: false, errorClass: "truncated", retryable: true };
+  if (reply.stop_reason === "refusal") return { ok: false, errorClass: "refused", retryable: true };
+  const text = reply.content?.filter((block) => block.type === "text").map((block) => block.text ?? "").join("") ?? "";
+  if (!text) return { ok: false, errorClass: "empty_response", retryable: true };
+  return { ok: true, text };
+}
+function anthropicProvider(config) {
+  const fetchImpl = config.fetchImpl ?? fetch;
+  const base = (config.baseUrl || "https://api.anthropic.com").replace(/\/+$/, "");
   return {
-    name: "nvidia",
-    generate: (prompt, options) => sdkGenerate(client.chat(model), prompt, options)
+    name: "anthropic",
+    async generate(prompt, options) {
+      try {
+        const system = options?.jsonMode ? `${prompt.system}
+
+Reply with one JSON value only, no prose and no code fences.` : prompt.system;
+        const response = await fetchImpl(`${base}/v1/messages`, {
+          method: "POST",
+          headers: { "content-type": "application/json", "x-api-key": config.apiKey, "anthropic-version": "2023-06-01" },
+          signal: options?.signal,
+          body: JSON.stringify({
+            model: config.model,
+            max_tokens: options?.maxTokens ?? 1800,
+            system,
+            messages: [{ role: "user", content: prompt.user }]
+          })
+        });
+        if (!response.ok) return httpOutcome(response.status);
+        return anthropicOutcome(await response.json());
+      } catch {
+        return { ok: false, errorClass: options?.signal?.aborted ? "timeout" : "transport", retryable: true };
+      }
+    }
   };
 }
 function geminiOutcome(data) {
@@ -367,68 +580,18 @@ function vertexProvider(config) {
     }
   };
 }
-function realProviders(env, purpose, fetchImpl) {
-  const providers = [];
-  const models = textModels(env, purpose);
-  if (env.GEMINI_API_KEY) {
-    providers.push(geminiProvider({ apiKey: env.GEMINI_API_KEY, model: models.gemini, fetchImpl }));
-  }
-  const openRouterModel = models.openrouter;
-  if (env.OPENROUTER_API_KEY) {
-    providers.push(
-      openRouterProvider({
-        apiKey: env.OPENROUTER_API_KEY,
-        model: openRouterModel,
-        baseUrl: env.OPENROUTER_BASE_URL,
-        allowPaidModels: env.OPENROUTER_ALLOW_PAID_MODELS,
-        fetch: fetchImpl
-      })
-    );
-  }
-  if (env.OPENROUTER_API_KEY_2) {
-    providers.push(
-      openRouterProvider({
-        apiKey: env.OPENROUTER_API_KEY_2,
-        model: openRouterModel,
-        baseUrl: env.OPENROUTER_BASE_URL,
-        allowPaidModels: env.OPENROUTER_ALLOW_PAID_MODELS,
-        fetch: fetchImpl,
-        name: "openrouter-2"
-      })
-    );
-  }
-  if (env.NVIDIA_API_KEY) {
-    providers.push(
-      nvidiaProvider({
-        apiKey: env.NVIDIA_API_KEY,
-        model: models.nvidia,
-        fetch: fetchImpl
-      })
-    );
-  }
-  if (paidAllowed(env) && vertexConfigured(env)) {
-    providers.push(
-      vertexProvider({
-        clientEmail: env.GOOGLE_CLIENT_EMAIL,
-        privateKey: env.GOOGLE_PRIVATE_KEY,
-        tokenUri: env.GOOGLE_TOKEN_URI,
-        project: env.GOOGLE_CLOUD_PROJECT,
-        model: models.vertex,
-        fetchImpl
-      })
-    );
-  }
-  return providers;
-}
 export {
   AI_COOLDOWN_MS,
   AI_TIMEOUT_MS,
   HEDGE,
+  anthropicOutcome,
+  anthropicProvider,
   createAiHealth,
   createAiService,
   geminiOutcome,
   geminiProvider,
   nvidiaProvider,
+  openAiCompatibleProvider,
   openRouterProvider,
   realProviders,
   sharedAiHealth,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sahan-sac/ai-core",
-  "version": "0.2.0",
-  "description": "Free-by-default AI provider chain (Gemini, OpenRouter, NVIDIA, Vertex) with hedging, cooldowns and deadlines, env-driven model resolution, image generation and prompt-injection guards. Shared by @sahan-sac/blog-kit and @sahan-sac/chat-kit.",
+  "version": "0.3.0",
+  "description": "Free-by-default AI provider chain with fallback (chain of responsibility over provider adapters: Gemini, OpenRouter, NVIDIA, OpenAI, Anthropic, DeepSeek, xAI, Perplexity, any OpenAI-compatible endpoint, Vertex), env-configurable order, hedging, cooldowns and deadlines, image generation and prompt-injection guards. Shared by @sahan-sac/blog-kit and @sahan-sac/chat-kit.",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -35,6 +35,10 @@
       "types": "./dist/models.d.ts",
       "import": "./dist/models.js"
     },
+    "./adapters": {
+      "types": "./dist/adapters.d.ts",
+      "import": "./dist/adapters.js"
+    },
     "./providers": {
       "types": "./dist/providers.d.ts",
       "import": "./dist/providers.js"