@sahan-sac/ai-core 0.2.0 → 0.3.0

package/dist/availability.js

@@ -1,13 +1,36 @@
-// src/image.ts
-import "server-only";
-
 // 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 DEFAULT_IMAGE_MODELS = {
   nvidia: "black-forest-labs/flux.1-dev",
   gemini: "gemini-3.1-flash-image",
   vertex: "gemini-3.1-flash-image"
 };
 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)
+  };
+}
 function imageModels(env) {
   return {
     nvidia: pick(env.IMAGE_NVIDIA_MODEL, DEFAULT_IMAGE_MODELS.nvidia),
@@ -19,8 +42,400 @@ 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/providers.ts
+import "server-only";
+import { createOpenAI } from "@ai-sdk/openai";
+import { generateText } from "ai";
+
+// 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 createAiHealth = () => ({ cooldownUntil: /* @__PURE__ */ new Map(), latencyMs: /* @__PURE__ */ new Map() });
+var sharedAiHealth = globalThis.sahanAiHealth ??= createAiHealth();
+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 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 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: "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) {
+  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 };
+      }
+    }
+  };
+}
+
+// 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));
+}
 
 // src/image.ts
+import "server-only";
 function vertexImageAvailable(env) {
   return vertexConfigured(env);
 }
@@ -43,18 +458,18 @@ function imageConfigFromEnv(env) {
 }
 
 // src/availability.ts
-function textAiConfigured(env) {
-  if (env.GEMINI_API_KEY || env.OPENROUTER_API_KEY || env.OPENROUTER_API_KEY_2 || env.NVIDIA_API_KEY) return true;
-  return paidAllowed(env) && vertexConfigured(env);
+function textAiConfigured(env, purpose) {
+  if (purpose) return chainPlan(env, purpose).length > 0;
+  return chainPlan(env, "blog").length > 0 || chainPlan(env, "chat").length > 0;
 }
 function blogAiEnabled(env) {
-  return env.ENABLE_BLOG_AI && textAiConfigured(env);
+  return env.ENABLE_BLOG_AI && textAiConfigured(env, "blog");
 }
 function blogAiImagesEnabled(env) {
   return blogAiEnabled(env) && imageConfigFromEnv(env) !== null;
 }
 function chatbotEnabled(env) {
-  return env.ENABLE_CHATBOT && textAiConfigured(env);
+  return env.ENABLE_CHATBOT && textAiConfigured(env, "chat");
 }
 export {
   blogAiEnabled,

package/dist/env.d.ts

@@ -27,6 +27,36 @@ declare const aiEnvSchema: z.ZodObject<{
     IMAGE_NVIDIA_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
     IMAGE_GEMINI_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
     IMAGE_VERTEX_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    AI_PROVIDER_ORDER: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    AI_PROVIDER_ORDER_BLOG: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    AI_PROVIDER_ORDER_CHAT: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    OPENAI_API_KEY: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    OPENAI_BASE_URL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    OPENAI_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    BLOG_OPENAI_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    CHAT_OPENAI_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    ANTHROPIC_API_KEY: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    ANTHROPIC_BASE_URL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    ANTHROPIC_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    BLOG_ANTHROPIC_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    CHAT_ANTHROPIC_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    DEEPSEEK_API_KEY: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    DEEPSEEK_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    BLOG_DEEPSEEK_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    CHAT_DEEPSEEK_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    XAI_API_KEY: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    XAI_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    BLOG_XAI_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    CHAT_XAI_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    PERPLEXITY_API_KEY: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    PERPLEXITY_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    BLOG_PERPLEXITY_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    CHAT_PERPLEXITY_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    AI_CUSTOM_BASE_URL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    AI_CUSTOM_API_KEY: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    AI_CUSTOM_MODEL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    AI_CUSTOM_NAME: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    AI_CUSTOM_FREE: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<boolean, string | undefined>>;
     GOOGLE_CLIENT_EMAIL: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
     GOOGLE_PRIVATE_KEY: z.ZodPipe<z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>, z.ZodTransform<string | undefined, string | undefined>>;
     GOOGLE_CLOUD_PROJECT: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;

package/dist/env.js

@@ -44,6 +44,45 @@ var aiEnvSchema = z.object({
   IMAGE_NVIDIA_MODEL: text,
   IMAGE_GEMINI_MODEL: text,
   IMAGE_VERTEX_MODEL: text,
+  // Provider order (./adapters). Comma-separated adapter ids; only the listed
+  // ones run, in that order. Per purpose first, then the global one; unset =
+  // the built-in order (free tiers first, paid last).
+  AI_PROVIDER_ORDER: text,
+  AI_PROVIDER_ORDER_BLOG: text,
+  AI_PROVIDER_ORDER_CHAT: text,
+  // Paid OpenAI-compatible and Anthropic providers: each joins a chain only
+  // with its key set and AI_ALLOW_PAID on. Models: purpose variable, then the
+  // provider-wide one, then the default in ./adapters.
+  OPENAI_API_KEY: text,
+  OPENAI_BASE_URL: text,
+  OPENAI_MODEL: text,
+  BLOG_OPENAI_MODEL: text,
+  CHAT_OPENAI_MODEL: text,
+  ANTHROPIC_API_KEY: text,
+  ANTHROPIC_BASE_URL: text,
+  ANTHROPIC_MODEL: text,
+  BLOG_ANTHROPIC_MODEL: text,
+  CHAT_ANTHROPIC_MODEL: text,
+  DEEPSEEK_API_KEY: text,
+  DEEPSEEK_MODEL: text,
+  BLOG_DEEPSEEK_MODEL: text,
+  CHAT_DEEPSEEK_MODEL: text,
+  XAI_API_KEY: text,
+  XAI_MODEL: text,
+  BLOG_XAI_MODEL: text,
+  CHAT_XAI_MODEL: text,
+  PERPLEXITY_API_KEY: text,
+  PERPLEXITY_MODEL: text,
+  BLOG_PERPLEXITY_MODEL: text,
+  CHAT_PERPLEXITY_MODEL: text,
+  // One custom OpenAI-compatible endpoint (a gateway, vLLM, Ollama, LiteLLM).
+  // Treated as paid unless AI_CUSTOM_FREE is on; the key is optional for a
+  // local server.
+  AI_CUSTOM_BASE_URL: text,
+  AI_CUSTOM_API_KEY: text,
+  AI_CUSTOM_MODEL: text,
+  AI_CUSTOM_NAME: text,
+  AI_CUSTOM_FREE: flag,
   // Google Vertex service account (paid).
   GOOGLE_CLIENT_EMAIL: text,
   GOOGLE_PRIVATE_KEY: privateKey,

package/dist/guard.d.ts

@@ -1,8 +1,20 @@
 declare const DATA_START = "<<<SAHAN_USER_DATA_START>>>";
 declare const DATA_END = "<<<SAHAN_USER_DATA_END>>>";
-/** Strips control characters, caps length, and neutralizes any attempt to
+/** Strips control characters, caps length (4000 by default), and neutralizes any attempt to
  * forge the delimiter markers themselves before fencing the text as data. */
-declare function wrapUserData(text: string): string;
+declare function wrapUserData(text: string, maxLength?: number): string;
+/** Longest owner guidance (per scope, after merging) that reaches a prompt. */
+declare const MAX_GUIDANCE_LENGTH = 6000;
+/**
+ * Standing guidance the site owner wrote in the admin settings (tone, facts,
+ * do and don't), appended to a system prompt. Unlike visitor or editor data
+ * it is meant to steer the model, so it is not fenced; it is still capped,
+ * stripped of control characters and forged fence markers, and placed after
+ * the fixed rules with a note that those rules win. Empty input gives "".
+ */
+declare function guidanceSection(guidance: string | null | undefined): string;
+/** Joins owner guidance from broad to specific (global, then a feature's own), skipping empty parts. */
+declare function mergeGuidance(...parts: Array<string | null | undefined>): string;
 interface ModelPrompt {
     system: string;
     user: string;
@@ -15,4 +27,4 @@ interface ModelPrompt {
  */
 declare function looksLikeLeak(text: string): boolean;
 
-export { DATA_END, DATA_START, type ModelPrompt, looksLikeLeak, wrapUserData };
+export { DATA_END, DATA_START, MAX_GUIDANCE_LENGTH, type ModelPrompt, guidanceSection, looksLikeLeak, mergeGuidance, wrapUserData };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { AiEnv, aiEnvFromProcess, aiEnvSchema, parseAiEnv } from './env.js';
 export { ImageModels, TextModels, TextPurpose } from './models.js';
-export { AiHealth, AiProvider, AiResult } from './providers.js';
+export { a as AdapterState, b as AdapterStatus, AiHealth, AiProvider, AiResult, c as ProviderAdapter } from './providers.js';
 export { ModelPrompt } from './guard.js';
 export { AiLogger } from './log.js';
 import 'zod';

package/dist/index.js

@@ -44,6 +44,45 @@ var aiEnvSchema = z.object({
   IMAGE_NVIDIA_MODEL: text,
   IMAGE_GEMINI_MODEL: text,
   IMAGE_VERTEX_MODEL: text,
+  // Provider order (./adapters). Comma-separated adapter ids; only the listed
+  // ones run, in that order. Per purpose first, then the global one; unset =
+  // the built-in order (free tiers first, paid last).
+  AI_PROVIDER_ORDER: text,
+  AI_PROVIDER_ORDER_BLOG: text,
+  AI_PROVIDER_ORDER_CHAT: text,
+  // Paid OpenAI-compatible and Anthropic providers: each joins a chain only
+  // with its key set and AI_ALLOW_PAID on. Models: purpose variable, then the
+  // provider-wide one, then the default in ./adapters.
+  OPENAI_API_KEY: text,
+  OPENAI_BASE_URL: text,
+  OPENAI_MODEL: text,
+  BLOG_OPENAI_MODEL: text,
+  CHAT_OPENAI_MODEL: text,
+  ANTHROPIC_API_KEY: text,
+  ANTHROPIC_BASE_URL: text,
+  ANTHROPIC_MODEL: text,
+  BLOG_ANTHROPIC_MODEL: text,
+  CHAT_ANTHROPIC_MODEL: text,
+  DEEPSEEK_API_KEY: text,
+  DEEPSEEK_MODEL: text,
+  BLOG_DEEPSEEK_MODEL: text,
+  CHAT_DEEPSEEK_MODEL: text,
+  XAI_API_KEY: text,
+  XAI_MODEL: text,
+  BLOG_XAI_MODEL: text,
+  CHAT_XAI_MODEL: text,
+  PERPLEXITY_API_KEY: text,
+  PERPLEXITY_MODEL: text,
+  BLOG_PERPLEXITY_MODEL: text,
+  CHAT_PERPLEXITY_MODEL: text,
+  // One custom OpenAI-compatible endpoint (a gateway, vLLM, Ollama, LiteLLM).
+  // Treated as paid unless AI_CUSTOM_FREE is on; the key is optional for a
+  // local server.
+  AI_CUSTOM_BASE_URL: text,
+  AI_CUSTOM_API_KEY: text,
+  AI_CUSTOM_MODEL: text,
+  AI_CUSTOM_NAME: text,
+  AI_CUSTOM_FREE: flag,
   // Google Vertex service account (paid).
   GOOGLE_CLIENT_EMAIL: text,
   GOOGLE_PRIVATE_KEY: privateKey,