@broberg/ai-sdk 0.6.0 → 0.8.0

package/dist/index.js

@@ -278,7 +278,9 @@ var PRICING = {
   "mistral:magistral-small-latest": { inputPer1M: 0.5, outputPer1M: 1.5, version: MS },
   "mistral:devstral-latest": { inputPer1M: 0.4, outputPer1M: 2, version: MS },
   "mistral:codestral-latest": { inputPer1M: 0.3, outputPer1M: 0.9, version: MS },
-  "mistral:open-mistral-nemo": { inputPer1M: 0.15, outputPer1M: 0.15, version: MS }
+  "mistral:open-mistral-nemo": { inputPer1M: 0.15, outputPer1M: 0.15, version: MS },
+  // Moderation (F016.4) — per input token; output 0. (OCR is per-page in the adapter.)
+  "mistral:mistral-moderation-latest": { inputPer1M: 0.1, outputPer1M: 0, version: MS }
 };
 function getPrice(provider, model) {
   const exact = PRICING[`${provider}:${model}`];
@@ -1025,12 +1027,150 @@ function openrouterAdapter(config = {}) {
 }
 
 // src/providers/mistral.ts
+var MISTRAL_OCR_PRICE_PER_PAGE = 2e-3;
 function mistralAdapter(config = {}) {
-  return makeOpenAICompatibleAdapter({
-    name: "mistral",
-    baseUrl: config.baseUrl ?? "https://api.mistral.ai/v1",
-    apiKey: config.apiKey
-  });
+  const baseUrl = config.baseUrl ?? "https://api.mistral.ai/v1";
+  const base = makeOpenAICompatibleAdapter({ name: "mistral", baseUrl, apiKey: config.apiKey });
+  function key() {
+    const k = config.apiKey ?? process.env.MISTRAL_API_KEY;
+    if (!k) throw new Error("mistral adapter: API key not set (env MISTRAL_API_KEY)");
+    return k;
+  }
+  const fetchImpl = config.fetch ?? fetch;
+  async function ocr(req) {
+    const isImage = (req.mimeType ?? "").startsWith("image/");
+    const url = typeof req.document === "string" ? req.document : `data:${req.mimeType ?? "application/pdf"};base64,${Buffer.from(req.document).toString("base64")}`;
+    const document = isImage ? { type: "image_url", image_url: url } : { type: "document_url", document_url: url };
+    const res = await fetchImpl(`${baseUrl}/ocr`, {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${key()}` },
+      body: JSON.stringify({ model: req.spec.model, document })
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`mistral ocr ${res.status}: ${body.slice(0, 300)}`);
+    }
+    const data = await res.json();
+    const pages = (data.pages ?? []).map((p, i) => ({
+      index: p.index ?? i,
+      markdown: p.markdown ?? ""
+    }));
+    const pagesProcessed = data.usage_info?.pages_processed ?? pages.length;
+    const usage = freshUsage({
+      provider: "mistral",
+      model: req.spec.model,
+      transport: "http",
+      capability: "ocr",
+      inputTokens: 0,
+      outputTokens: 0
+    });
+    usage.costUsd = pagesProcessed * (config.pricePerPage ?? MISTRAL_OCR_PRICE_PER_PAGE);
+    return { pages, usage };
+  }
+  async function moderate(req) {
+    const res = await fetchImpl(`${baseUrl}/moderations`, {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${key()}` },
+      body: JSON.stringify({ model: req.spec.model, input: req.input })
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`mistral moderation ${res.status}: ${body.slice(0, 300)}`);
+    }
+    const data = await res.json();
+    const results = (data.results ?? []).map((r) => {
+      const categories = r.categories ?? {};
+      return {
+        flagged: Object.values(categories).some(Boolean),
+        categories,
+        categoryScores: r.category_scores ?? {}
+      };
+    });
+    const estIn = req.input.reduce((n, s) => n + Math.ceil(s.length / 4), 0);
+    const usage = freshUsage({
+      provider: "mistral",
+      model: req.spec.model,
+      transport: "http",
+      capability: "moderation",
+      inputTokens: data.usage?.prompt_tokens ?? estIn,
+      outputTokens: 0
+    });
+    return { results, usage };
+  }
+  return { ...base, ocr, moderate };
+}
+
+// src/providers/elevenlabs.ts
+var ELEVENLABS_PRICE_PER_1K_CHARS = 0.15;
+var ELEVENLABS_DANISH_VOICES = {
+  soren: "xj6X4BCUsv9oxohm1E8o",
+  jesper: "Bl1YwS3uJac5zEOSNESn",
+  mads: "BIWC0507fYMfhPcAEIRP",
+  noam: "V34B5u5UbLdNJVEkcgXp",
+  camilla: "4RklGmuxoAskAbGXplXN"
+};
+function resolveVoice(nameOrId) {
+  return ELEVENLABS_DANISH_VOICES[nameOrId] ?? nameOrId;
+}
+function elevenlabsAdapter(config = {}) {
+  const baseUrl = config.baseUrl ?? "https://api.elevenlabs.io/v1";
+  const fetchImpl = config.fetch ?? fetch;
+  function key() {
+    const k = config.apiKey ?? process.env.ELEVENLABS_API_KEY;
+    if (!k) throw new Error("elevenlabs adapter: API key not set (env ELEVENLABS_API_KEY)");
+    return k;
+  }
+  function priceFor(chars, model) {
+    const usage = freshUsage({
+      provider: "elevenlabs",
+      model,
+      transport: "http",
+      capability: "podcast",
+      inputTokens: 0,
+      outputTokens: 0
+    });
+    usage.costUsd = chars / 1e3 * (config.pricePer1kChars ?? ELEVENLABS_PRICE_PER_1K_CHARS);
+    return usage;
+  }
+  async function dialogue(req) {
+    const res = await fetchImpl(`${baseUrl}/text-to-dialogue`, {
+      method: "POST",
+      headers: { "xi-api-key": key(), "content-type": "application/json", accept: "audio/mpeg" },
+      body: JSON.stringify({
+        model_id: req.spec.model,
+        inputs: req.inputs.map((t) => ({ text: t.text, voice_id: t.voiceId })),
+        ...req.format ? { output_format: req.format } : {}
+      })
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`elevenlabs dialogue ${res.status}: ${body.slice(0, 300)}`);
+    }
+    const audio = new Uint8Array(await res.arrayBuffer());
+    const chars = req.inputs.reduce((n, t) => n + t.text.length, 0);
+    return { audio, mimeType: "audio/mpeg", usage: priceFor(chars, req.spec.model) };
+  }
+  async function tts(req) {
+    const model = req.spec.model;
+    const res = await fetchImpl(`${baseUrl}/text-to-speech/${req.voiceId}`, {
+      method: "POST",
+      headers: { "xi-api-key": key(), "content-type": "application/json", accept: "audio/mpeg" },
+      body: JSON.stringify({ text: req.text, model_id: model })
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new Error(`elevenlabs tts ${res.status}: ${body.slice(0, 300)}`);
+    }
+    const audio = new Uint8Array(await res.arrayBuffer());
+    return { audio, mimeType: "audio/mpeg", usage: priceFor(req.text.length, model) };
+  }
+  async function listVoices() {
+    const res = await fetchImpl(`${baseUrl}/voices`, { headers: { "xi-api-key": key() } });
+    if (!res.ok) throw new Error(`elevenlabs voices ${res.status}`);
+    const data = await res.json();
+    return (data.voices ?? []).map((v) => ({ voiceId: v.voice_id, name: v.name, language: v.labels?.language }));
+  }
+  return { name: "elevenlabs", dialogue, tts, listVoices };
 }
 
 // src/providers/fal.ts
@@ -1121,6 +1261,7 @@ var defaultProviders = {
   deepinfra: deepinfraAdapter(),
   openrouter: openrouterAdapter(),
   mistral: mistralAdapter(),
+  elevenlabs: elevenlabsAdapter(),
   fal: falAdapter()
 };
 
@@ -1432,6 +1573,28 @@ var transcribeInputSchema = z.object({
   durationSec: z.number().positive().optional(),
   ...callOptions
 });
+var ocrInputSchema = z.object({
+  /** A URL, data-URL, or raw bytes of the document/image. */
+  document: z.union([z.string(), z.instanceof(Uint8Array)]),
+  /** image/* → routed as an image; anything else → a document (PDF etc.). */
+  mimeType: z.string().optional(),
+  ...callOptions
+});
+var moderationInputSchema = z.object({
+  input: z.union([z.string(), z.array(z.string())]),
+  ...callOptions
+});
+var podcastInputSchema = z.object({
+  script: z.array(z.object({ speaker: z.string(), text: z.string() })).min(1),
+  voices: z.record(z.string(), z.string()),
+  format: z.string().optional(),
+  ...callOptions
+});
+var ttsInputSchema = z.object({
+  text: z.string(),
+  voice: z.string(),
+  ...callOptions
+});
 var budgetSchema = z.object({
   perCallUsd: z.number().positive().optional(),
   rollingUsd: z.number().positive().optional()
@@ -1451,6 +1614,10 @@ var DEFAULT_IMAGE_SPEC = {
   model: "fal-ai/flux/schnell",
   transport: "http"
 };
+var DEFAULT_OCR_SPEC = { provider: "mistral", model: "mistral-ocr-latest", transport: "http" };
+var DEFAULT_MODERATION_SPEC = { provider: "mistral", model: "mistral-moderation-latest", transport: "http" };
+var DEFAULT_PODCAST_SPEC = { provider: "elevenlabs", model: "eleven_v3", transport: "http" };
+var DEFAULT_TTS_SPEC = { provider: "elevenlabs", model: "eleven_multilingual_v2", transport: "http" };
 function createAI(config = {}) {
   const cfg = aiConfigSchema.parse(config);
   const providers = cfg.providers ?? defaultProviders;
@@ -1694,6 +1861,84 @@ function createAI(config = {}) {
         }
       });
     },
+    async ocr(input) {
+      input = ocrInputSchema.parse(input);
+      return runCapability({
+        primary: { ...DEFAULT_OCR_SPEC, ...input.override },
+        fallback: input.fallback,
+        capability: "ocr",
+        purpose: input.purpose,
+        labels: input.labels,
+        estIn: 0,
+        // OCR cost is per-page, not token-based
+        estOut: 0,
+        invoke: async (spec) => {
+          const adapter = pickProvider(spec.provider);
+          if (!adapter.ocr) throw new Error(`createAI: provider "${spec.provider}" does not support ocr`);
+          return adapter.ocr({ document: input.document, mimeType: input.mimeType, spec });
+        }
+      });
+    },
+    async moderate(input) {
+      input = moderationInputSchema.parse(input);
+      const items = Array.isArray(input.input) ? input.input : [input.input];
+      return runCapability({
+        primary: { ...DEFAULT_MODERATION_SPEC, ...input.override },
+        fallback: input.fallback,
+        capability: "moderation",
+        purpose: input.purpose,
+        labels: input.labels,
+        estIn: items.reduce((n, s) => n + estTokens(s), 0),
+        estOut: 0,
+        invoke: async (spec) => {
+          const adapter = pickProvider(spec.provider);
+          if (!adapter.moderate) throw new Error(`createAI: provider "${spec.provider}" does not support moderation`);
+          return adapter.moderate({ input: items, spec });
+        }
+      });
+    },
+    async podcast(input) {
+      input = podcastInputSchema.parse(input);
+      const inputs = input.script.map((turn) => {
+        const mapped = input.voices[turn.speaker];
+        if (!mapped) throw new Error(`ai.podcast: no voice mapped for speaker "${turn.speaker}"`);
+        return { text: turn.text, voiceId: resolveVoice(mapped) };
+      });
+      const chars = input.script.reduce((n, t) => n + t.text.length, 0);
+      return runCapability({
+        primary: { ...DEFAULT_PODCAST_SPEC, ...input.override },
+        fallback: input.fallback,
+        capability: "podcast",
+        purpose: input.purpose,
+        labels: input.labels,
+        estIn: chars,
+        // per-character cost (not token-based)
+        estOut: 0,
+        invoke: async (spec) => {
+          const adapter = pickProvider(spec.provider);
+          if (!adapter.dialogue) throw new Error(`createAI: provider "${spec.provider}" does not support podcast/dialogue`);
+          return adapter.dialogue({ inputs, format: input.format, spec });
+        }
+      });
+    },
+    async tts(input) {
+      input = ttsInputSchema.parse(input);
+      return runCapability({
+        primary: { ...DEFAULT_TTS_SPEC, ...input.override },
+        fallback: input.fallback,
+        capability: "tts",
+        purpose: input.purpose,
+        labels: input.labels,
+        estIn: input.text.length,
+        // per-character cost
+        estOut: 0,
+        invoke: async (spec) => {
+          const adapter = pickProvider(spec.provider);
+          if (!adapter.tts) throw new Error(`createAI: provider "${spec.provider}" does not support tts`);
+          return adapter.tts({ text: input.text, voiceId: resolveVoice(input.voice), spec });
+        }
+      });
+    },
     async embedding(input) {
       input = embeddingInputSchema.parse(input);
       const tier = input.tier ?? EMBEDDING_DEFAULT_TIER;
@@ -1820,8 +2065,8 @@ var stubProviders = {
 };
 
 // src/version.ts
-var VERSION = "0.6.0";
-var SDK_TAG = "@broberg/ai-sdk@0.6.0";
+var VERSION = "0.8.0";
+var SDK_TAG = "@broberg/ai-sdk@0.8.0";
 
 // src/cost/budget-store.ts
 function sqliteBudgetStore(config) {
@@ -2053,6 +2298,7 @@ export {
   BudgetExceededError,
   BudgetGuard,
   DEFAULT_TIER_MAP,
+  ELEVENLABS_DANISH_VOICES,
   SDK_TAG,
   StreamHttpError,
   VERSION,
@@ -2066,6 +2312,7 @@ export {
   deepinfraAdapter,
   defaultProviders,
   discordSink,
+  elevenlabsAdapter,
   embeddingInputSchema,
   falAdapter,
   falStubAdapter,
@@ -2088,6 +2335,7 @@ export {
   parseClaudeCliJson,
   parseJsonLoose,
   resolveTier,
+  resolveVoice,
   sqliteBudgetStore,
   sqliteSink,
   streamTransport,