@jz92/ai-provider 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,109 @@
+import * as zod from 'zod';
+import { ZodSchema } from 'zod';
+
+type AIProviderName = 'ollama' | 'anthropic' | 'openai' | 'google' | 'groq' | 'mistral';
+type AIEnvironment = 'development' | 'test' | 'production';
+type ProviderConfig = {
+    provider: AIProviderName;
+    model: string;
+    baseURL?: string;
+    maxTokens: number;
+    usePromptCache: boolean;
+    env: AIEnvironment;
+};
+type AIRequestOptions<T = string> = {
+    /** The user-facing prompt — the dynamic part of every request */
+    prompt: string;
+    /** Stable system instructions — cached in production (Anthropic), baked into Modelfile locally */
+    systemPrompt: string;
+    /** Zod schema for structured output. Required for generateStructured(). */
+    schema?: zod.ZodSchema<T>;
+    /** Deterministic key — same key returns cached result without hitting the API */
+    cacheKey?: string;
+    /** Rough token ceiling on input. Throws before the API call if exceeded. Default 8000. */
+    maxInputTokens?: number;
+};
+type AIResponse<T> = {
+    data: T;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        /** Provider-side cache token count. Only populated if the provider returns
+         *  cache metadata in the response (currently Anthropic via the Vercel AI SDK).
+         *  Defaults to 0 for providers that do not yet expose this. */
+        cachedTokens: number;
+    };
+    provider: AIProviderName;
+    model: string;
+    fromCache: boolean;
+};
+
+/**
+ * generateStructured — typed, validated JSON output.
+ *
+ * @example
+ * const result = await generateStructured({
+ *   systemPrompt: MY_SYSTEM_PROMPT,
+ *   prompt: userInput,
+ *   schema: z.object({ name: z.string() }),
+ *   cacheKey: `parse:${userInput}`,
+ * })
+ */
+declare function generateStructured<T>(options: AIRequestOptions<T> & {
+    schema: ZodSchema<T>;
+}): Promise<AIResponse<T>>;
+/**
+ * generatePlainText — unstructured text output.
+ */
+declare function generatePlainText(options: Omit<AIRequestOptions, 'schema'>): Promise<AIResponse<string>>;
+
+/**
+ * Resolves which AI provider + model to use based on NODE_ENV.
+ *
+ * Default routing:
+ *   development  → Ollama (local, free, no API key)
+ *   test         → Anthropic Haiku (cheap, real API, for CI)
+ *   production   → Anthropic Sonnet with prompt caching
+ *
+ * Override anything via env vars:
+ *   AI_PROVIDER=openai|anthropic|google|groq|mistral|ollama
+ *   AI_MODEL=<model string>
+ *   OLLAMA_MODEL=<named variant>
+ *   OLLAMA_BASE_URL=<url>
+ *
+ * Provider-specific defaults when AI_PROVIDER is set:
+ *   openai    → gpt-4o-mini (test) / gpt-4o (prod)
+ *   google    → gemini-1.5-flash (test) / gemini-1.5-pro (prod)
+ *   groq      → llama-3.1-8b-instant (test) / llama-3.1-70b-versatile (prod)
+ *   mistral   → mistral-small-latest (test) / mistral-large-latest (prod)
+ */
+declare function resolveProvider(): ProviderConfig;
+
+declare class BoundedCache {
+    private store;
+    private readonly maxSize;
+    private readonly ttlMs;
+    constructor(maxSize?: number, ttlMs?: number);
+    get<T>(key: string): T | null;
+    set<T>(key: string, value: T): void;
+    delete(key: string): void;
+    /** Clear all entries — useful between tests */
+    clear(): void;
+    get size(): number;
+}
+declare const responseCache: BoundedCache;
+
+/**
+ * Error classification for the retry logic.
+ * We only retry transient errors — never auth, billing, or validation failures.
+ */
+declare class AIProviderError extends Error {
+    readonly code: AIErrorCode;
+    readonly provider?: string | undefined;
+    readonly status?: number | undefined;
+    readonly cause?: unknown | undefined;
+    constructor(message: string, code: AIErrorCode, provider?: string | undefined, status?: number | undefined, cause?: unknown | undefined);
+}
+type AIErrorCode = 'AUTH_ERROR' | 'BILLING_ERROR' | 'RATE_LIMIT' | 'SERVER_ERROR' | 'TIMEOUT' | 'MODEL_NOT_FOUND' | 'TOKEN_BUDGET' | 'SCHEMA_VALIDATION' | 'UNKNOWN';
+
+export { type AIEnvironment, type AIErrorCode, AIProviderError, type AIProviderName, type AIRequestOptions, type AIResponse, type ProviderConfig, generatePlainText, generateStructured, resolveProvider, responseCache };

package/dist/index.js

@@ -0,0 +1,541 @@
+// src/gateway.ts
+import { generateObject, generateText } from "ai";
+
+// src/provider.ts
+function resolveProvider() {
+  const env = resolveEnvironment();
+  const providerOverride = process.env.AI_PROVIDER;
+  const modelOverride = process.env.AI_MODEL;
+  if (providerOverride && providerOverride !== "ollama") {
+    return buildCloudConfig(providerOverride, env, modelOverride);
+  }
+  if (providerOverride === "ollama") {
+    return buildOllamaConfig(modelOverride);
+  }
+  switch (env) {
+    case "development":
+      return buildOllamaConfig(modelOverride);
+    case "test":
+      return buildCloudConfig("anthropic", "test", modelOverride);
+    case "production":
+      return buildCloudConfig("anthropic", "production", modelOverride);
+  }
+}
+function resolveEnvironment() {
+  const raw = process.env.NODE_ENV;
+  if (raw === "test") return "test";
+  if (raw === "production") return "production";
+  return "development";
+}
+function buildOllamaConfig(modelOverride) {
+  return {
+    provider: "ollama",
+    model: modelOverride ?? process.env.OLLAMA_MODEL ?? "qwen2.5-coder:14b",
+    baseURL: process.env.OLLAMA_BASE_URL ?? "http://localhost:11434",
+    maxTokens: 2048,
+    usePromptCache: false,
+    env: "development"
+  };
+}
+function buildCloudConfig(provider, env, modelOverride) {
+  const isTest = env === "test";
+  const defaults = {
+    anthropic: {
+      test: "claude-haiku-4-5-20251001",
+      production: "claude-sonnet-4-6"
+    },
+    openai: {
+      test: "gpt-4o-mini",
+      production: "gpt-4o"
+    },
+    google: {
+      test: "gemini-1.5-flash",
+      production: "gemini-1.5-pro"
+    },
+    groq: {
+      test: "llama-3.1-8b-instant",
+      production: "llama-3.1-70b-versatile"
+    },
+    mistral: {
+      test: "mistral-small-latest",
+      production: "mistral-large-latest"
+    }
+  };
+  return {
+    provider,
+    model: modelOverride ?? defaults[provider][isTest ? "test" : "production"],
+    maxTokens: isTest ? 512 : 1024,
+    // Only Anthropic supports prompt caching via this SDK
+    usePromptCache: provider === "anthropic" && !isTest,
+    env
+  };
+}
+
+// src/errors.ts
+var AIProviderError = class extends Error {
+  constructor(message, code, provider, status, cause) {
+    super(message);
+    this.code = code;
+    this.provider = provider;
+    this.status = status;
+    this.cause = cause;
+    this.name = "AIProviderError";
+  }
+};
+function isRetryable(code) {
+  return code === "RATE_LIMIT" || code === "SERVER_ERROR" || code === "TIMEOUT";
+}
+function classifyError(err) {
+  const message = errorMessage(err);
+  const status = extractStatus(err);
+  if (status === 401) return "AUTH_ERROR";
+  if (status === 402) return "BILLING_ERROR";
+  if (status === 403) return "BILLING_ERROR";
+  if (status === 404) return "MODEL_NOT_FOUND";
+  if (status === 429) return "RATE_LIMIT";
+  if (status >= 500 && status < 600) return "SERVER_ERROR";
+  const lower = message.toLowerCase();
+  if (lower.includes("api key") || lower.includes("authentication") || lower.includes("unauthorized"))
+    return "AUTH_ERROR";
+  if (lower.includes("credit") || lower.includes("billing") || lower.includes("quota"))
+    return "BILLING_ERROR";
+  if (lower.includes("rate limit") || lower.includes("too many requests"))
+    return "RATE_LIMIT";
+  if (lower.includes("timeout") || lower.includes("timed out") || lower.includes("etimedout"))
+    return "TIMEOUT";
+  if (lower.includes("model") && (lower.includes("not found") || lower.includes("pull")))
+    return "MODEL_NOT_FOUND";
+  if (lower.includes("schema") || lower.includes("validation") || lower.includes("parse"))
+    return "SCHEMA_VALIDATION";
+  return "UNKNOWN";
+}
+function wrapError(err, provider) {
+  const code = classifyError(err);
+  const status = extractStatus(err);
+  const message = buildMessage(code, provider, errorMessage(err));
+  return new AIProviderError(message, code, provider, status, err);
+}
+function buildMessage(code, provider, raw) {
+  switch (code) {
+    case "AUTH_ERROR":
+      return `[ai-provider] Authentication failed for "${provider}".
+Check your API key is set correctly and hasn't expired.
+Env var: ${providerKeyName(provider)}`;
+    case "BILLING_ERROR":
+      return `[ai-provider] Billing or quota issue for "${provider}".
+Check your account has active credits at the provider dashboard.`;
+    case "RATE_LIMIT":
+      return `[ai-provider] Rate limit hit for "${provider}".
+Request will be retried with exponential backoff.`;
+    case "MODEL_NOT_FOUND":
+      return `[ai-provider] Model not found for "${provider}".
+If using Ollama locally, run: ollama pull <model-name>
+Raw: ${raw}`;
+    case "TIMEOUT":
+      return `[ai-provider] Request timed out for "${provider}".
+Check your network connection and provider status.`;
+    case "SCHEMA_VALIDATION":
+      return `[ai-provider] Response from "${provider}" did not match the expected schema.
+Try making your system prompt more explicit about the output format.
+Raw: ${raw}`;
+    default:
+      return `[ai-provider] Unexpected error from "${provider}": ${raw}`;
+  }
+}
+function providerKeyName(provider) {
+  const keys = {
+    anthropic: "ANTHROPIC_API_KEY",
+    openai: "OPENAI_API_KEY",
+    google: "GOOGLE_GENERATIVE_AI_API_KEY",
+    groq: "GROQ_API_KEY",
+    mistral: "MISTRAL_API_KEY"
+  };
+  return keys[provider] ?? `${provider.toUpperCase()}_API_KEY`;
+}
+function extractStatus(err) {
+  if (err && typeof err === "object") {
+    if ("status" in err && typeof err.status === "number")
+      return err.status;
+    if ("statusCode" in err && typeof err.statusCode === "number")
+      return err.statusCode;
+  }
+  return 0;
+}
+function errorMessage(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  return String(err);
+}
+
+// src/client.ts
+async function buildModel(config) {
+  switch (config.provider) {
+    case "ollama":
+      return buildOllamaModel(config);
+    case "anthropic":
+      return buildAnthropicModel(config);
+    case "openai":
+      return buildOpenAIModel(config);
+    case "google":
+      return buildGoogleModel(config);
+    case "groq":
+      return buildGroqModel(config);
+    case "mistral":
+      return buildMistralModel(config);
+  }
+}
+async function buildOllamaModel(config) {
+  await assertOllamaReachable(config.baseURL ?? "http://localhost:11434");
+  try {
+    const { createOllama } = await import("ollama-ai-provider");
+    const ollama = createOllama({ baseURL: `${config.baseURL}/api` });
+    return ollama(config.model);
+  } catch (err) {
+    if (isModuleNotFound(err)) {
+      throw new AIProviderError(
+        "[ai-provider] ollama-ai-provider is not installed.\nRun: npm install ollama-ai-provider",
+        "UNKNOWN",
+        "ollama"
+      );
+    }
+    throw err;
+  }
+}
+async function assertOllamaReachable(baseURL) {
+  try {
+    const res = await fetch(baseURL, { signal: AbortSignal.timeout(3e3) });
+    if (!res.ok && res.status !== 200) throw new Error(`status ${res.status}`);
+  } catch {
+    throw new AIProviderError(
+      `[ai-provider] Ollama is not reachable at ${baseURL}.
+
+  Start Ollama:       brew services start ollama
+  Or (foreground):    ollama serve
+
+  To use a cloud provider instead:
+    Set AI_PROVIDER=anthropic (and ANTHROPIC_API_KEY) in your .env
+    Or: AI_PROVIDER=openai (and OPENAI_API_KEY)
+    Or: AI_PROVIDER=groq   (and GROQ_API_KEY \u2014 free tier available)`,
+      "UNKNOWN",
+      "ollama"
+    );
+  }
+}
+async function buildAnthropicModel(config) {
+  assertKey("ANTHROPIC_API_KEY", "anthropic", "@ai-sdk/anthropic");
+  try {
+    const { createAnthropic } = await import("@ai-sdk/anthropic");
+    const anthropic = createAnthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+    return anthropic(config.model);
+  } catch (err) {
+    if (isModuleNotFound(err)) notInstalled("@ai-sdk/anthropic");
+    throw err;
+  }
+}
+async function buildOpenAIModel(config) {
+  assertKey("OPENAI_API_KEY", "openai", "@ai-sdk/openai");
+  try {
+    const { createOpenAI } = await import("@ai-sdk/openai");
+    const openai = createOpenAI({ apiKey: process.env.OPENAI_API_KEY });
+    return openai(config.model);
+  } catch (err) {
+    if (isModuleNotFound(err)) notInstalled("@ai-sdk/openai");
+    throw err;
+  }
+}
+async function buildGoogleModel(config) {
+  assertKey("GOOGLE_GENERATIVE_AI_API_KEY", "google", "@ai-sdk/google");
+  try {
+    const { createGoogleGenerativeAI } = await import("@ai-sdk/google");
+    const google = createGoogleGenerativeAI({ apiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY });
+    return google(config.model);
+  } catch (err) {
+    if (isModuleNotFound(err)) notInstalled("@ai-sdk/google");
+    throw err;
+  }
+}
+async function buildGroqModel(config) {
+  assertKey("GROQ_API_KEY", "groq", "@ai-sdk/groq");
+  try {
+    const { createGroq } = await import("@ai-sdk/groq");
+    const groq = createGroq({ apiKey: process.env.GROQ_API_KEY });
+    return groq(config.model);
+  } catch (err) {
+    if (isModuleNotFound(err)) notInstalled("@ai-sdk/groq");
+    throw err;
+  }
+}
+async function buildMistralModel(config) {
+  assertKey("MISTRAL_API_KEY", "mistral", "@ai-sdk/mistral");
+  try {
+    const { createMistral } = await import("@ai-sdk/mistral");
+    const mistral = createMistral({ apiKey: process.env.MISTRAL_API_KEY });
+    return mistral(config.model);
+  } catch (err) {
+    if (isModuleNotFound(err)) notInstalled("@ai-sdk/mistral");
+    throw err;
+  }
+}
+function assertKey(envVar, provider, pkg) {
+  if (!process.env[envVar]) {
+    throw new AIProviderError(
+      `[ai-provider] ${envVar} is not set.
+
+  This is required for the "${provider}" provider.
+
+  1. Install the SDK:   npm install ${pkg}
+  2. Set the key:
+       Local:       add ${envVar}=<your-key> to .env.local
+       Vercel:      add it in Project Settings \u2192 Environment Variables
+       AWS:         add it to your task definition or Secrets Manager
+       GitHub CI:   add it to repo secrets and reference as \${{ secrets.${envVar} }}
+
+  Get a key at: ${providerDashboard(provider)}`,
+      "AUTH_ERROR",
+      provider
+    );
+  }
+}
+function notInstalled(pkg) {
+  throw new AIProviderError(
+    `[ai-provider] ${pkg} is not installed.
+Run: npm install ${pkg}`,
+    "UNKNOWN"
+  );
+}
+function isModuleNotFound(err) {
+  return err instanceof Error && "code" in err && err.code === "ERR_MODULE_NOT_FOUND";
+}
+function providerDashboard(provider) {
+  const dashboards = {
+    anthropic: "https://console.anthropic.com",
+    openai: "https://platform.openai.com/api-keys",
+    google: "https://aistudio.google.com/app/apikey",
+    groq: "https://console.groq.com/keys",
+    mistral: "https://console.mistral.ai/api-keys"
+  };
+  return dashboards[provider] ?? `https://${provider}.com`;
+}
+
+// src/cache.ts
+var BoundedCache = class {
+  constructor(maxSize, ttlMs) {
+    this.store = /* @__PURE__ */ new Map();
+    this.maxSize = maxSize ?? parseInt(process.env.AI_CACHE_MAX_SIZE ?? "500", 10);
+    this.ttlMs = ttlMs ?? parseInt(process.env.AI_CACHE_TTL_MS ?? String(5 * 60 * 1e3), 10);
+  }
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry) return null;
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
+  set(key, value) {
+    if (this.store.size >= this.maxSize) {
+      const oldestKey = this.store.keys().next().value;
+      if (oldestKey) this.store.delete(oldestKey);
+    }
+    this.store.set(key, {
+      value,
+      expiresAt: Date.now() + this.ttlMs
+    });
+  }
+  delete(key) {
+    this.store.delete(key);
+  }
+  /** Clear all entries — useful between tests */
+  clear() {
+    this.store.clear();
+  }
+  get size() {
+    return this.store.size;
+  }
+};
+var responseCache = new BoundedCache();
+
+// src/gateway.ts
+var TIMEOUT_MS = {
+  ollama: parseInt(process.env.AI_TIMEOUT_MS ?? "60000", 10),
+  anthropic: parseInt(process.env.AI_TIMEOUT_MS ?? "30000", 10),
+  openai: parseInt(process.env.AI_TIMEOUT_MS ?? "30000", 10),
+  google: parseInt(process.env.AI_TIMEOUT_MS ?? "30000", 10),
+  groq: parseInt(process.env.AI_TIMEOUT_MS ?? "30000", 10),
+  mistral: parseInt(process.env.AI_TIMEOUT_MS ?? "30000", 10)
+};
+async function generateStructured(options) {
+  const config = resolveProvider();
+  const cached = responseCache.get(options.cacheKey ?? "");
+  if (cached && options.cacheKey) {
+    return { data: cached, provider: config.provider, model: config.model, fromCache: true };
+  }
+  guardTokenBudget(options.systemPrompt + options.prompt, options.maxInputTokens ?? 8e3);
+  const model = await buildModel(config);
+  const messages = buildMessages(config, options.systemPrompt, options.prompt);
+  const timeout = TIMEOUT_MS[config.provider];
+  const result = await withRetry(
+    () => withTimeout(
+      () => generateObject({ model, messages, schema: options.schema, maxTokens: config.maxTokens }),
+      timeout
+    ),
+    config.provider
+  );
+  return buildResponse(result.object, result.usage, config, options.cacheKey);
+}
+async function generatePlainText(options) {
+  const config = resolveProvider();
+  const cached = responseCache.get(options.cacheKey ?? "");
+  if (cached && options.cacheKey) {
+    return { data: cached, provider: config.provider, model: config.model, fromCache: true };
+  }
+  guardTokenBudget(options.systemPrompt + options.prompt, options.maxInputTokens ?? 8e3);
+  const model = await buildModel(config);
+  const messages = buildMessages(config, options.systemPrompt, options.prompt);
+  const timeout = TIMEOUT_MS[config.provider];
+  const result = await withRetry(
+    () => withTimeout(
+      () => generateText({ model, messages, maxTokens: config.maxTokens }),
+      timeout
+    ),
+    config.provider
+  );
+  return buildResponse(result.text, result.usage, config, options.cacheKey);
+}
+function buildMessages(config, systemPrompt, userPrompt) {
+  if (config.usePromptCache) {
+    return [
+      { role: "system", content: systemPrompt },
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: userPrompt,
+            experimental_providerMetadata: {
+              anthropic: { cacheControl: { type: "ephemeral" } }
+            }
+          }
+        ]
+      }
+    ];
+  }
+  return [
+    { role: "system", content: systemPrompt },
+    { role: "user", content: userPrompt }
+  ];
+}
+function buildResponse(data, usage, config, cacheKey) {
+  if (cacheKey) responseCache.set(cacheKey, data);
+  let cachedTokens = 0;
+  if (usage?.experimental_providerMetadata) {
+    const meta = usage.experimental_providerMetadata;
+    const anthropic = meta?.anthropic;
+    cachedTokens = (anthropic?.cacheReadInputTokens ?? 0) + (anthropic?.cacheCreationInputTokens ?? 0);
+  }
+  const response = {
+    data,
+    usage: usage ? {
+      inputTokens: usage.promptTokens,
+      outputTokens: usage.completionTokens,
+      cachedTokens
+    } : void 0,
+    provider: config.provider,
+    model: config.model,
+    fromCache: false
+  };
+  logUsage(config, response);
+  return response;
+}
+function logUsage(config, response) {
+  const isDev = config.env === "development";
+  const forceLog = process.env.AI_LOG_USAGE === "true";
+  if (!isDev && !forceLog) return;
+  const u = response.usage;
+  const width = 41;
+  const line = (label, value) => {
+    const content = `  ${label.padEnd(10)} ${value}`;
+    const pad = width - content.length - 1;
+    return `\x1B[2m[ai-provider]\x1B[0m \u2502${content}${" ".repeat(Math.max(0, pad))}\u2502`;
+  };
+  const bar = (char) => `\x1B[2m[ai-provider]\x1B[0m ${char}${"\u2500".repeat(width)}${char === "\u250C" ? "\u2510" : "\u2518"}`;
+  const lines = [bar("\u250C")];
+  lines.push(line("provider", `\x1B[36m${config.provider}\x1B[0m \x1B[2m(${config.env})\x1B[0m`));
+  lines.push(line("model", `\x1B[36m${config.model}\x1B[0m`));
+  if (response.fromCache) {
+    lines.push(line("tokens", "\x1B[2mskipped \u2014 response cache hit\x1B[0m"));
+  } else if (u) {
+    const tokenStr = `in: \x1B[33m${u.inputTokens}\x1B[0m  out: \x1B[33m${u.outputTokens}\x1B[0m`;
+    lines.push(line("tokens", tokenStr));
+    if (u.cachedTokens > 0) {
+      const pct = Math.round(u.cachedTokens / u.inputTokens * 100);
+      lines.push(line("cached", `\x1B[32m${u.cachedTokens} tokens (${pct}% of input)\x1B[0m`));
+    }
+  } else {
+    lines.push(line("tokens", "\x1B[2munavailable\x1B[0m"));
+  }
+  lines.push(bar("\u2514"));
+  lines.forEach((l) => console.log(l));
+}
+function guardTokenBudget(text, maxTokens) {
+  const estimate = Math.ceil(text.length / 4);
+  if (estimate > maxTokens) {
+    throw new AIProviderError(
+      `[ai-provider] Input exceeds token budget.
+Estimated ~${estimate} tokens, limit is ${maxTokens}.
+Trim your prompt or raise maxInputTokens in your call options.`,
+      "TOKEN_BUDGET"
+    );
+  }
+}
+async function withTimeout(fn, timeoutMs) {
+  let timer;
+  const timeoutPromise = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      reject(new AIProviderError(
+        `[ai-provider] Request timed out after ${timeoutMs}ms.
+If using Ollama locally, the model may still be loading \u2014 try again in a few seconds.
+Override timeout: AI_TIMEOUT_MS=90000`,
+        "TIMEOUT"
+      ));
+    }, timeoutMs);
+  });
+  try {
+    const result = await Promise.race([fn(), timeoutPromise]);
+    clearTimeout(timer);
+    return result;
+  } catch (err) {
+    clearTimeout(timer);
+    throw err;
+  }
+}
+async function withRetry(fn, provider, maxRetries = 2) {
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      const wrapped = err instanceof AIProviderError ? err : wrapError(err, provider);
+      if (!isRetryable(wrapped.code)) {
+        throw wrapped;
+      }
+      lastError = wrapped;
+      if (attempt < maxRetries) {
+        const backoff = 500 * Math.pow(2, attempt);
+        if (process.env.AI_LOG_USAGE === "true") {
+          console.warn(`[ai-provider] Retrying (attempt ${attempt + 1}/${maxRetries}) after ${backoff}ms \u2014 ${wrapped.code}`);
+        }
+        await new Promise((r) => setTimeout(r, backoff));
+      }
+    }
+  }
+  throw lastError;
+}
+export {
+  AIProviderError,
+  generatePlainText,
+  generateStructured,
+  resolveProvider,
+  responseCache
+};