@sahan-sac/ai-core 0.2.0 → 0.3.1

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

@@ -1,434 +1,35 @@
-// src/providers.ts
-import "server-only";
-import { createOpenAI } from "@ai-sdk/openai";
-import { generateText } from "ai";
-
-// src/log.ts
-var consoleAiLogger = {
-  warn(message, meta) {
-    console.warn(JSON.stringify({ level: "warn", message, ...meta }));
-  }
-};
-
-// src/models.ts
-var DEFAULT_TEXT_MODELS = {
-  // Long structured JSON: a full flash model, not lite.
-  blog: {
-    gemini: "gemini-2.5-flash",
-    openrouter: "nvidia/nemotron-3-super-120b-a12b:free",
-    nvidia: "nvidia/nemotron-3-super-120b-a12b",
-    vertex: "gemini-2.5-flash"
-  },
-  // Short, latency-sensitive replies: the fastest free model first.
-  chat: {
-    gemini: "gemini-3.1-flash-lite",
-    openrouter: "nvidia/nemotron-3-super-120b-a12b:free",
-    nvidia: "nvidia/nemotron-3-super-120b-a12b",
-    vertex: "gemini-2.5-flash"
-  }
-};
-var pick = (...values) => values.find((value) => value && value.trim()).trim();
-function textModels(env, purpose) {
-  const defaults = DEFAULT_TEXT_MODELS[purpose];
-  const own = purpose === "blog" ? { gemini: env.BLOG_GEMINI_MODEL, openrouter: env.BLOG_OPENROUTER_MODEL, nvidia: env.BLOG_NVIDIA_MODEL, vertex: env.BLOG_VERTEX_MODEL } : { gemini: env.CHAT_GEMINI_MODEL, openrouter: env.CHAT_OPENROUTER_MODEL, nvidia: env.CHAT_NVIDIA_MODEL, vertex: env.CHAT_VERTEX_MODEL };
-  return {
-    gemini: pick(own.gemini, env.GEMINI_MODEL, defaults.gemini),
-    openrouter: pick(own.openrouter, env.OPENROUTER_MODEL, defaults.openrouter),
-    nvidia: pick(own.nvidia, env.NVIDIA_MODEL, defaults.nvidia),
-    vertex: pick(own.vertex, env.VERTEX_MODEL, defaults.vertex)
-  };
-}
-var paidAllowed = (env) => env.AI_ALLOW_PAID === true;
-function vertexConfigured(env) {
-  return Boolean(env.GOOGLE_CLIENT_EMAIL && env.GOOGLE_PRIVATE_KEY && env.GOOGLE_CLOUD_PROJECT);
-}
-function thinkingConfigFor(model, maxOutputTokens) {
-  const long = maxOutputTokens >= 2e3;
-  if (/^gemini-[3-9]/.test(model)) {
-    return { thinkingLevel: long ? "low" : /flash/.test(model) ? "minimal" : "low" };
-  }
-  return { thinkingBudget: long ? Math.min(800, Math.floor(maxOutputTokens / 5)) : 0 };
-}
-
-// src/vertex.ts
-import "server-only";
-var cachedToken = null;
-function base64UrlEncode(input) {
-  return Buffer.from(input).toString("base64url");
-}
-async function getVertexAccessToken(account, fetchImpl = fetch) {
-  const now = Date.now();
-  if (cachedToken && cachedToken.expiresAt - 6e4 > now) return cachedToken.accessToken;
-  const { createSign } = await import("crypto");
-  const issuedAt = Math.floor(now / 1e3);
-  const expiresIn = 3600;
-  const header = base64UrlEncode(JSON.stringify({ alg: "RS256", typ: "JWT" }));
-  const claims = base64UrlEncode(
-    JSON.stringify({
-      iss: account.clientEmail,
-      scope: "https://www.googleapis.com/auth/cloud-platform",
-      aud: account.tokenUri,
-      iat: issuedAt,
-      exp: issuedAt + expiresIn
-    })
-  );
-  const signingInput = `${header}.${claims}`;
-  const signature = createSign("RSA-SHA256").update(signingInput).sign(account.privateKey);
-  const jwt = `${signingInput}.${base64UrlEncode(signature)}`;
-  const response = await fetchImpl(account.tokenUri, {
-    method: "POST",
-    headers: { "content-type": "application/x-www-form-urlencoded" },
-    body: new URLSearchParams({
-      grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
-      assertion: jwt
-    })
-  });
-  if (!response.ok) {
-    throw new Error(`Vertex token exchange failed: HTTP ${response.status}`);
-  }
-  const data = await response.json();
-  cachedToken = { accessToken: data.access_token, expiresAt: now + data.expires_in * 1e3 };
-  return data.access_token;
-}
-
-// src/providers.ts
-function jsonConfig(jsonMode) {
-  if (!jsonMode) return {};
-  return typeof jsonMode === "object" ? { responseMimeType: "application/json", responseSchema: jsonMode.schema } : { responseMimeType: "application/json" };
-}
-var AI_TIMEOUT_MS = 25e3;
-var AI_COOLDOWN_MS = 6e4;
-async function attempt(provider, prompt, maxTokens, ms, cancel, jsonMode) {
-  const controller = new AbortController();
-  const onCancel = () => controller.abort();
-  cancel.addEventListener("abort", onCancel, { once: true });
-  let timer;
-  const timeout = new Promise((resolve) => {
-    timer = setTimeout(() => {
-      controller.abort();
-      resolve({ ok: false, errorClass: "timeout", retryable: true });
-    }, ms);
-  });
-  try {
-    return await Promise.race([provider.generate(prompt, { maxTokens, signal: controller.signal, jsonMode }), timeout]);
-  } catch {
-    return { ok: false, errorClass: "transport", retryable: true };
-  } finally {
-    clearTimeout(timer);
-    cancel.removeEventListener("abort", onCancel);
-  }
-}
-var createAiHealth = () => ({ cooldownUntil: /* @__PURE__ */ new Map(), latencyMs: /* @__PURE__ */ new Map() });
-var sharedAiHealth = globalThis.sahanAiHealth ??= createAiHealth();
-function cooldownFor(outcome) {
-  if (outcome.ok) return 0;
-  if (outcome.errorClass === "timeout" || outcome.status === 429) return AI_COOLDOWN_MS;
-  if (outcome.status === 401 || outcome.status === 403 || outcome.status === 404) return AI_COOLDOWN_MS * 10;
-  return 0;
-}
-var HEDGE = /* @__PURE__ */ Symbol("hedge");
-function createAiService(deps) {
-  const timeoutMs = deps.timeoutMs ?? AI_TIMEOUT_MS;
-  const now = deps.now ?? Date.now;
-  const health = deps.health ?? createAiHealth();
-  const logger = deps.logger ?? consoleAiLogger;
-  function rank(at) {
-    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));
-  }
-  async function generate(prompt, options) {
-    if (deps.providers.length === 0) {
-      return { ok: false, provider: null, errorClass: "no_provider", attempts: [] };
-    }
-    const startedAll = now();
-    const ordered = rank(startedAll);
-    const attempts = [];
-    const cancelLosers = new AbortController();
-    const running = /* @__PURE__ */ new Set();
-    let next = 0;
-    let stopped = false;
-    let result = null;
-    let rejected;
-    const launch = () => {
-      if (result || stopped || next >= ordered.length) return false;
-      const remaining = deps.deadlineMs === void 0 ? timeoutMs : deps.deadlineMs - (now() - startedAll);
-      if (remaining <= 250) return false;
-      const provider = ordered[next++];
-      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;
-        const ms = now() - started;
-        let outcome = raw;
-        if (outcome.ok && options?.accept) {
-          const reason = options.accept(outcome.text);
-          if (reason) {
-            rejected = { provider: provider.name, text: outcome.text, reason };
-            outcome = { ok: false, errorClass: "invalid_output", retryable: true };
-          }
-        }
-        if (outcome.ok) {
-          health.cooldownUntil.delete(provider.name);
-          const previous = health.latencyMs.get(provider.name);
-          health.latencyMs.set(provider.name, previous === void 0 ? ms : Math.round(previous * 0.7 + ms * 0.3));
-          attempts.push({ provider: provider.name, ok: true, ms });
-          result = { ok: true, provider: provider.name, text: outcome.text, attempts };
-          options?.onAttempt?.({ provider: provider.name, stage: "success" });
-          cancelLosers.abort();
-          return;
-        }
-        attempts.push({ provider: provider.name, ok: false, errorClass: outcome.errorClass, ms });
-        const fallbackTo = next < ordered.length ? ordered[next].name : void 0;
-        options?.onAttempt?.({
-          provider: provider.name,
-          stage: fallbackTo ? "fallback" : "failure",
-          errorClass: outcome.errorClass,
-          fallbackTo
-        });
-        const cooldown = cooldownFor(outcome);
-        if (cooldown) health.cooldownUntil.set(provider.name, now() + cooldown);
-        logger.warn("ai provider failed", {
-          provider: provider.name,
-          errorClass: outcome.errorClass,
-          ms,
-          ...outcome.errorClass === "invalid_output" && rejected ? { reason: rejected.reason.slice(0, 160) } : {}
-        });
-        if (!outcome.retryable) stopped = true;
-      });
-      const tracked = run.finally(() => running.delete(tracked));
-      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)));
-      }
-      const first = await Promise.race(racers);
-      clearTimeout(timer);
-      if (first === HEDGE) launch();
-    }
-    return result ?? { ok: false, provider: null, errorClass: attempts[attempts.length - 1]?.errorClass ?? "deadline", attempts, rejected };
-  }
-  return { generate };
-}
-function httpOutcome(status) {
-  return { ok: false, errorClass: `http_${status}`, retryable: true, status };
-}
-var FREE_SUFFIX = ":free";
-function openRouterProvider(config) {
-  const model = config.model || DEFAULT_TEXT_MODELS.blog.openrouter;
-  const client = createOpenAI({
-    apiKey: config.apiKey,
-    baseURL: config.baseUrl || "https://openrouter.ai/api/v1",
-    fetch: config.fetch
-  });
-  return {
-    name: config.name ?? "openrouter",
-    async generate(prompt, options) {
-      if (!config.allowPaidModels && !model.endsWith(FREE_SUFFIX)) {
-        return { ok: false, errorClass: "paid_model_blocked", retryable: true };
-      }
-      return sdkGenerate(client.chat(model), prompt, options);
-    }
-  };
-}
-async function sdkGenerate(model, prompt, options) {
-  try {
-    const result = await generateText({
-      model,
-      system: prompt.system,
-      prompt: prompt.user,
-      maxOutputTokens: options?.maxTokens ?? 1200,
-      maxRetries: 0,
-      abortSignal: options?.signal
-    });
-    if (!result.text) return { ok: false, errorClass: "empty_response", retryable: true };
-    if (result.finishReason === "length") return { ok: false, errorClass: "truncated", retryable: true };
-    return { ok: true, text: result.text };
-  } catch (error) {
-    const status = error?.statusCode ?? error?.status;
-    if (status) return httpOutcome(status);
-    return { ok: false, errorClass: options?.signal?.aborted ? "timeout" : "provider_error", retryable: true };
-  }
-}
-function nvidiaProvider(config) {
-  const model = config.model || DEFAULT_TEXT_MODELS.blog.nvidia;
-  const client = createOpenAI({
-    apiKey: config.apiKey,
-    baseURL: "https://integrate.api.nvidia.com/v1",
-    fetch: config.fetch
-  });
-  return {
-    name: "nvidia",
-    generate: (prompt, options) => sdkGenerate(client.chat(model), prompt, options)
-  };
-}
-function geminiOutcome(data) {
-  const candidate = data.candidates?.[0];
-  const text = candidate?.content?.parts?.filter((part) => !part.thought).map((part) => part.text ?? "").join("") ?? "";
-  if (candidate?.finishReason === "MAX_TOKENS") return { ok: false, errorClass: "truncated", retryable: true };
-  if (!text) return { ok: false, errorClass: "empty_response", retryable: true };
-  return { ok: true, text };
-}
-function geminiProvider(config) {
-  const model = config.model || DEFAULT_TEXT_MODELS.blog.gemini;
-  const fetchImpl = config.fetchImpl ?? fetch;
-  return {
-    name: "gemini",
-    async generate(prompt, options) {
-      try {
-        const maxOutputTokens = options?.maxTokens ?? 2400;
-        const generationConfig = {
-          maxOutputTokens,
-          thinkingConfig: thinkingConfigFor(model, maxOutputTokens),
-          ...jsonConfig(options?.jsonMode)
-        };
-        let response = await fetchImpl(
-          `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`,
-          {
-            method: "POST",
-            // Header, not ?key=: query strings end up in proxy and access logs.
-            headers: { "content-type": "application/json", "x-goog-api-key": config.apiKey },
-            signal: options?.signal,
-            body: JSON.stringify({
-              systemInstruction: { parts: [{ text: prompt.system }] },
-              contents: [{ role: "user", parts: [{ text: prompt.user }] }],
-              generationConfig
-            })
-          }
-        );
-        if (response.status === 503 && !options?.signal?.aborted) {
-          await new Promise((r) => setTimeout(r, 500));
-          if (!options?.signal?.aborted) {
-            response = await fetchImpl(
-              `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent`,
-              {
-                method: "POST",
-                headers: { "content-type": "application/json", "x-goog-api-key": config.apiKey },
-                signal: options?.signal,
-                body: JSON.stringify({
-                  systemInstruction: { parts: [{ text: prompt.system }] },
-                  contents: [{ role: "user", parts: [{ text: prompt.user }] }],
-                  generationConfig
-                })
-              }
-            );
-          }
-        }
-        if (!response.ok) return httpOutcome(response.status);
-        return geminiOutcome(await response.json());
-      } catch {
-        return { ok: false, errorClass: options?.signal?.aborted ? "timeout" : "transport", retryable: true };
-      }
-    }
-  };
-}
-function vertexProvider(config) {
-  const model = config.model || DEFAULT_TEXT_MODELS.blog.vertex;
-  const location = config.location ?? (/^gemini-[3-9]/.test(model) ? "global" : "us-central1");
-  const host = location === "global" ? "aiplatform.googleapis.com" : `${location}-aiplatform.googleapis.com`;
-  const fetchImpl = config.fetchImpl ?? fetch;
-  return {
-    name: "vertex",
-    lastResort: true,
-    async generate(prompt, options) {
-      try {
-        const accessToken = await getVertexAccessToken(
-          { clientEmail: config.clientEmail, privateKey: config.privateKey, tokenUri: config.tokenUri },
-          fetchImpl
-        );
-        const response = await fetchImpl(
-          `https://${host}/v1/projects/${config.project}/locations/${location}/publishers/google/models/${model}:generateContent`,
-          {
-            method: "POST",
-            headers: { "content-type": "application/json", authorization: `Bearer ${accessToken}` },
-            signal: options?.signal,
-            body: JSON.stringify({
-              systemInstruction: { parts: [{ text: prompt.system }] },
-              contents: [{ role: "user", parts: [{ text: prompt.user }] }],
-              generationConfig: {
-                maxOutputTokens: options?.maxTokens ?? 1800,
-                thinkingConfig: thinkingConfigFor(model, options?.maxTokens ?? 1800),
-                ...jsonConfig(options?.jsonMode)
-              }
-            })
-          }
-        );
-        if (!response.ok) return httpOutcome(response.status);
-        return geminiOutcome(await response.json());
-      } catch {
-        return { ok: false, errorClass: "transport", retryable: true };
-      }
-    }
-  };
-}
-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;
-}
+import {
+  AI_COOLDOWN_MS,
+  AI_TIMEOUT_MS,
+  HEDGE,
+  anthropicOutcome,
+  anthropicProvider,
+  createAiHealth,
+  createAiService,
+  geminiOutcome,
+  geminiProvider,
+  nvidiaProvider,
+  openAiCompatibleProvider,
+  openRouterProvider,
+  realProviders,
+  sharedAiHealth,
+  vertexProvider
+} from "./chunk-R3YY2Y7S.js";
+import "./chunk-BL4J2JNX.js";
+import "./chunk-PMC3UWQ2.js";
+import "./chunk-RBSLNDFW.js";
 export {
   AI_COOLDOWN_MS,
   AI_TIMEOUT_MS,
   HEDGE,
+  anthropicOutcome,
+  anthropicProvider,
   createAiHealth,
   createAiService,
   geminiOutcome,
   geminiProvider,
   nvidiaProvider,
+  openAiCompatibleProvider,
   openRouterProvider,
   realProviders,
   sharedAiHealth,