@fraza/module-ai 0.0.0-stage → 0.4.22

package/dist/config.server.js

@@ -0,0 +1,113 @@
+const PROVIDERS = Object.freeze({
+  anthropic: { label: "Anthropic", needsKey: true, baseUrl: "https://api.anthropic.com" },
+  openai: { label: "OpenAI", needsKey: true, baseUrl: "https://api.openai.com/v1" },
+  google: { label: "Google", needsKey: true, baseUrl: "https://generativelanguage.googleapis.com/v1beta" },
+  mistral: { label: "Mistral", needsKey: true, baseUrl: "https://api.mistral.ai/v1" },
+  "openai-compatible": { label: "Compatible OpenAI", needsKey: false, baseUrl: null },
+  ollama: { label: "Ollama", needsKey: false, baseUrl: "http://localhost:11434" }
+});
+const DEFAULT_TIMEOUT_MS = 12e4;
+const DEFAULT_RETENTION_DAYS = 90;
+const TIMEOUT_BOUNDS = [5e3, 6e5];
+const RETENTION_BOUNDS = [1, 3650];
+class AiConfigError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AiConfigError";
+  }
+}
+function env(key) {
+  const value = process.env[key];
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : null;
+}
+function boundedInteger(key, fallback, [min, max]) {
+  const raw = env(key);
+  if (raw === null) return fallback;
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value < min || value > max) {
+    throw new AiConfigError(`${key} doit \xEAtre un entier entre ${min} et ${max}.`);
+  }
+  return value;
+}
+function readBaseUrl(provider) {
+  const raw = env("FRAZA_MODULE_AI_BASE_URL") ?? PROVIDERS[provider].baseUrl;
+  if (!raw) throw new AiConfigError(`FRAZA_MODULE_AI_BASE_URL est requise pour le fournisseur \xAB ${provider} \xBB.`);
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new AiConfigError("FRAZA_MODULE_AI_BASE_URL doit \xEAtre une adresse compl\xE8te, comme \xAB https://api.exemple.com/v1 \xBB.");
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw new AiConfigError("FRAZA_MODULE_AI_BASE_URL doit commencer par https:// ou http://.");
+  }
+  return raw.replace(/\/+$/, "");
+}
+function getAiConfig() {
+  const provider = env("FRAZA_MODULE_AI_PROVIDER");
+  if (!provider) throw new AiConfigError("FRAZA_MODULE_AI_PROVIDER est requise.");
+  if (!Object.hasOwn(PROVIDERS, provider)) {
+    throw new AiConfigError(`FRAZA_MODULE_AI_PROVIDER doit valoir ${Object.keys(PROVIDERS).join(", ")}.`);
+  }
+  const model = env("FRAZA_MODULE_AI_MODEL");
+  if (!model) throw new AiConfigError("FRAZA_MODULE_AI_MODEL est requise : le nom du mod\xE8le, tel que le fournisseur le donne.");
+  const apiKey = env("FRAZA_MODULE_AI_API_KEY");
+  if (PROVIDERS[provider].needsKey && !apiKey) {
+    throw new AiConfigError(`FRAZA_MODULE_AI_API_KEY est requise pour le fournisseur \xAB ${provider} \xBB.`);
+  }
+  return {
+    provider,
+    model,
+    apiKey,
+    baseUrl: readBaseUrl(provider),
+    timeoutMs: boundedInteger("FRAZA_MODULE_AI_TIMEOUT_MS", DEFAULT_TIMEOUT_MS, TIMEOUT_BOUNDS)
+  };
+}
+function getRetentionDays() {
+  return boundedInteger("FRAZA_MODULE_AI_RETENTION_DAYS", DEFAULT_RETENTION_DAYS, RETENTION_BOUNDS);
+}
+function isAiEnabled() {
+  return env("FRAZA_MODULE_AI") === "true";
+}
+function describeAiConfig() {
+  const provider = env("FRAZA_MODULE_AI_PROVIDER");
+  const known = provider && Object.hasOwn(PROVIDERS, provider);
+  const summary = {
+    configured: false,
+    provider: provider ?? null,
+    providerLabel: known ? PROVIDERS[provider].label : null,
+    model: env("FRAZA_MODULE_AI_MODEL"),
+    hasKey: env("FRAZA_MODULE_AI_API_KEY") !== null,
+    // Only the address of a self-hosted service: it says where the data goes.
+    baseUrl: known && !PROVIDERS[provider].needsKey ? env("FRAZA_MODULE_AI_BASE_URL") ?? PROVIDERS[provider].baseUrl : null,
+    problem: null
+  };
+  try {
+    getAiConfig();
+    summary.configured = true;
+  } catch (err) {
+    summary.problem = err instanceof AiConfigError ? err.message : "Configuration illisible.";
+  }
+  if (summary.configured) {
+    try {
+      getRetentionDays();
+    } catch (err) {
+      summary.problem = err.message;
+    }
+  }
+  return summary;
+}
+function isAiConfigured() {
+  return describeAiConfig().configured;
+}
+export {
+  AiConfigError,
+  DEFAULT_RETENTION_DAYS,
+  DEFAULT_TIMEOUT_MS,
+  PROVIDERS,
+  describeAiConfig,
+  getAiConfig,
+  getRetentionDays,
+  isAiConfigured,
+  isAiEnabled
+};

package/dist/cron.server.js

@@ -0,0 +1,26 @@
+import { schedule } from "@fraza/core/cron";
+import { fail } from "@fraza/core/shared/logger";
+import { getRetentionDays } from "./config.server.js";
+import { purgeDismissedResults } from "./results.server.js";
+import { purgeRuns } from "./runs.server.js";
+const RETENTION_JOB = "ai-retention";
+async function runRetention({ signal } = {}) {
+  const days = getRetentionDays();
+  const runs = await purgeRuns({ days, signal });
+  const results = await purgeDismissedResults({ days, signal });
+  return { runs, results };
+}
+async function registerCronJobs() {
+  try {
+    await schedule(RETENTION_JOB, "17 3 * * *", ({ signal }) => runRetention({ signal }), {
+      lock: { ttlSeconds: 900 }
+    });
+  } catch (err) {
+    fail(`AI: job ${RETENTION_JOB} could not be scheduled`, err);
+  }
+}
+export {
+  RETENTION_JOB,
+  registerCronJobs,
+  runRetention
+};

package/dist/db.server.js

@@ -0,0 +1,65 @@
+import { query, tableExists } from "@fraza/core/database";
+const TABLES = [
+  {
+    name: "fraza_ai_run",
+    sql: [
+      `CREATE TABLE fraza_ai_run (
+        id BIGSERIAL PRIMARY KEY,
+        prompt VARCHAR(120) NOT NULL,
+        source VARCHAR(214),
+        trigger VARCHAR(20) NOT NULL,
+        provider VARCHAR(40) NOT NULL,
+        model VARCHAR(200),
+        status VARCHAR(20) NOT NULL CHECK (status IN ('success', 'error')),
+        error_code VARCHAR(40),
+        error_message TEXT,
+        input_tokens INTEGER,
+        output_tokens INTEGER,
+        attempts SMALLINT NOT NULL DEFAULT 1,
+        duration_ms INTEGER,
+        user_id TEXT,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+      )`,
+      `CREATE INDEX fraza_ai_run_created_idx ON fraza_ai_run (created_at)`
+    ]
+  },
+  {
+    name: "fraza_ai_result",
+    sql: [
+      `CREATE TABLE fraza_ai_result (
+        id BIGSERIAL PRIMARY KEY,
+        target_type VARCHAR(120) NOT NULL,
+        target_id VARCHAR(120) NOT NULL,
+        prompt VARCHAR(120) NOT NULL,
+        data JSONB NOT NULL,
+        model VARCHAR(200),
+        created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+        dismissed_at TIMESTAMPTZ,
+        CONSTRAINT fraza_ai_result_target_unique UNIQUE (target_type, target_id, prompt)
+      )`
+    ]
+  }
+];
+async function createTables() {
+  const created = [];
+  const skipped = [];
+  for (const table of TABLES) {
+    if (await tableExists(table.name)) {
+      skipped.push(table.name);
+      continue;
+    }
+    for (const statement of table.sql) await query(statement);
+    created.push(table.name);
+  }
+  return { created, skipped };
+}
+async function dropTables() {
+  for (const table of [...TABLES].reverse()) {
+    await query(`DROP TABLE IF EXISTS ${table.name} CASCADE`);
+  }
+}
+export {
+  createTables,
+  dropTables
+};

package/dist/index.js

@@ -0,0 +1,41 @@
+import { MODULE_VERSION } from "./version.js";
+import { AI_PERMISSIONS } from "./permissions.js";
+const manifest = {
+  name: "@fraza/module-ai",
+  version: MODULE_VERSION,
+  permissions: [
+    {
+      key: AI_PERMISSIONS.USE,
+      name: "Utiliser l'IA",
+      description: "Lancer les boutons d'IA des \xE9crans de l'admin et voir les propositions de l'IA",
+      group_name: "IA"
+    },
+    {
+      key: AI_PERMISSIONS.VIEW,
+      name: "Voir la page IA",
+      description: "Configuration du fournisseur, prompts d\xE9clar\xE9s, historique des appels et jetons consomm\xE9s",
+      group_name: "IA"
+    }
+  ],
+  envVars: [
+    { key: "FRAZA_MODULE_AI", required: true, description: "Active le module IA (true / false)." },
+    { key: "FRAZA_MODULE_AI_PROVIDER", required: true, description: "Fournisseur d'IA : anthropic, openai, google, mistral, openai-compatible ou ollama." },
+    { key: "FRAZA_MODULE_AI_MODEL", required: true, description: "Mod\xE8le, tel que le fournisseur le nomme." },
+    { key: "FRAZA_MODULE_AI_API_KEY", required: false, description: "Cl\xE9 d'API du fournisseur. Requise sauf pour Ollama et un service compatible sans cl\xE9." },
+    { key: "FRAZA_MODULE_AI_BASE_URL", required: false, description: "Adresse de l'API. Requise pour openai-compatible ; http://localhost:11434 par d\xE9faut pour ollama." },
+    { key: "FRAZA_MODULE_AI_TIMEOUT_MS", required: false, description: "Attente maximale d'un appel, en millisecondes. 120000 par d\xE9faut." },
+    { key: "FRAZA_MODULE_AI_RETENTION_DAYS", required: false, description: "Jours d'historique des appels conserv\xE9s. 90 par d\xE9faut." }
+  ]
+};
+async function register() {
+  await import("./register-server.js");
+}
+import { createTables, dropTables } from "./db.server.js";
+import { migrations } from "./migrations.js";
+export {
+  createTables,
+  dropTables,
+  manifest,
+  migrations,
+  register
+};

package/dist/integration.server.js

@@ -0,0 +1,28 @@
+import { provideIntegration } from "@fraza/core/integrations";
+import { isAiConfigured } from "./config.server.js";
+import { definePrompt } from "./prompts.server.js";
+import { deleteResults, dismissResult, getResults, saveResult } from "./results.server.js";
+import { runPrompt } from "./run.server.js";
+import { getUsage } from "./runs.server.js";
+import { SOURCE } from "./source.js";
+const AI_CONTRACT = 1;
+const AI_FEATURES = Object.freeze(["html", "hints", "compose", "plan", "hint-groups"]);
+function provideAiIntegration() {
+  provideIntegration("ai", {
+    contract: AI_CONTRACT,
+    features: AI_FEATURES,
+    definePrompt,
+    runPrompt,
+    saveResult,
+    getResults,
+    dismissResult,
+    deleteResults,
+    isAiConfigured,
+    getUsage
+  }, { source: SOURCE });
+}
+export {
+  AI_CONTRACT,
+  AI_FEATURES,
+  provideAiIntegration
+};

package/dist/migrations.js

@@ -0,0 +1,4 @@
+const migrations = [];
+export {
+  migrations
+};

package/dist/permissions.js

@@ -0,0 +1,9 @@
+const AI_PERMISSIONS = Object.freeze({
+  /** Run the AI buttons of the admin screens. */
+  USE: "ai.use",
+  /** Open the AI page: configuration, prompts, history and usage. */
+  VIEW: "ai.view"
+});
+export {
+  AI_PERMISSIONS
+};

package/dist/prompts.server.js

@@ -0,0 +1,149 @@
+import { checkSchema } from "./schema.js";
+import { checkHints, checkSuggestions, STUDIO_INPUT } from "./studio.js";
+const NAME_PATTERN = /^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)*$/;
+const MODES = /* @__PURE__ */ new Set(["fill", "choose", "studio"]);
+const DEFAULT_MAX_TOKENS = 16e3;
+const MAX_TOKENS_LIMIT = 128e3;
+const PROJECT_SOURCE = "projet";
+const STATE_KEY = /* @__PURE__ */ Symbol.for("__FRAZA_AI_PROMPTS__");
+function state() {
+  globalThis[STATE_KEY] ??= { prompts: /* @__PURE__ */ new Map(), customizations: /* @__PURE__ */ new Map(), global: { instructions: null } };
+  return globalThis[STATE_KEY];
+}
+function isText(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function optionalText(value, key, name) {
+  if (value !== void 0 && typeof value !== "string") throw new TypeError(`definePrompt(${name}): ${key} must be a string`);
+}
+function checkDefinition(definition) {
+  if (!definition || typeof definition !== "object") throw new TypeError("definePrompt: the definition must be an object");
+  const { name } = definition;
+  if (typeof name !== "string" || !NAME_PATTERN.test(name)) {
+    throw new TypeError(`definePrompt: the name must be lowercase words, e.g. 'posts.write' (got ${JSON.stringify(name)})`);
+  }
+  const at = JSON.stringify(name);
+  if (definition.target !== void 0 && !(typeof definition.target === "string" && NAME_PATTERN.test(definition.target))) {
+    throw new TypeError(`definePrompt(${at}): target must be lowercase words, e.g. 'posts.post'`);
+  }
+  if (definition.target !== void 0 && !isText(definition.label)) {
+    throw new TypeError(`definePrompt(${at}): a prompt with a target needs a label, the text of its button`);
+  }
+  if (definition.mode !== void 0 && !MODES.has(definition.mode)) throw new TypeError(`definePrompt(${at}): mode must be 'fill', 'choose' or 'studio'`);
+  if (definition.mode === "studio") {
+    if (definition.input !== void 0) throw new TypeError(`definePrompt(${at}): a studio prompt has no input, its form is the request`);
+    checkSuggestions(definition.suggestions, `definePrompt(${at})`);
+    checkHints(definition.hints, `definePrompt(${at})`);
+  } else if (definition.suggestions !== void 0 || definition.hints !== void 0) {
+    throw new TypeError(`definePrompt(${at}): suggestions and hints belong to a studio prompt`);
+  }
+  for (const key of ["label", "heading", "description", "permission", "system", "instructions"]) optionalText(definition[key], key, at);
+  if (typeof definition.build !== "function") throw new TypeError(`definePrompt(${at}): build({ input, context, scope, instructions }) is required`);
+  if (typeof definition.output !== "function") checkSchema(definition.output, `${name}.output`);
+  if (definition.input !== void 0) {
+    checkSchema(definition.input, `${name}.input`);
+    const nested = Object.entries(definition.input.properties).filter(([, node]) => [node.type].flat().some((type) => type === "array" || type === "object")).map(([key]) => key);
+    if (nested.length > 0) throw new TypeError(`definePrompt(${at}): input takes texts, numbers and booleans only (${nested.join(", ")})`);
+  }
+  const { maxTokens } = definition;
+  if (maxTokens !== void 0 && !(Number.isInteger(maxTokens) && maxTokens > 0 && maxTokens <= MAX_TOKENS_LIMIT)) {
+    throw new TypeError(`definePrompt(${at}): maxTokens must be an integer from 1 to ${MAX_TOKENS_LIMIT}`);
+  }
+}
+function definePrompt(definition, { source = PROJECT_SOURCE } = {}) {
+  checkDefinition(definition);
+  const { prompts } = state();
+  const existing = prompts.get(definition.name);
+  if (existing && existing.source !== source) {
+    throw new TypeError(`definePrompt: ${JSON.stringify(definition.name)} is already declared by ${existing.source}`);
+  }
+  const studio = definition.mode === "studio";
+  prompts.set(definition.name, Object.freeze({
+    mode: "fill",
+    maxTokens: DEFAULT_MAX_TOKENS,
+    ...definition,
+    ...studio ? { input: STUDIO_INPUT, suggestions: checkSuggestions(definition.suggestions, definition.name), hints: checkHints(definition.hints, definition.name) } : {},
+    source
+  }));
+  return definition.name;
+}
+const CUSTOMIZABLE = /* @__PURE__ */ new Set(["system", "instructions", "label", "heading", "description", "enabled"]);
+function customizePrompt(name, changes) {
+  if (typeof name !== "string" || !NAME_PATTERN.test(name)) throw new TypeError(`customizePrompt: unknown prompt name ${JSON.stringify(name)}`);
+  if (!changes || typeof changes !== "object") throw new TypeError(`customizePrompt(${JSON.stringify(name)}): the changes must be an object`);
+  for (const [key, value] of Object.entries(changes)) {
+    if (!CUSTOMIZABLE.has(key)) {
+      throw new TypeError(`customizePrompt(${JSON.stringify(name)}): ${key} cannot be changed; declare a prompt of the project for another shape`);
+    }
+    const ok = key === "enabled" ? typeof value === "boolean" : key === "system" || key === "instructions" ? typeof value === "string" || typeof value === "function" : typeof value === "string";
+    if (!ok) throw new TypeError(`customizePrompt(${JSON.stringify(name)}): ${key} has the wrong type`);
+  }
+  const { customizations } = state();
+  customizations.set(name, { ...customizations.get(name), ...changes });
+}
+function configureAi({ instructions } = {}) {
+  if (instructions !== void 0 && instructions !== null && typeof instructions !== "string") {
+    throw new TypeError("configureAi: instructions must be a string");
+  }
+  state().global.instructions = isText(instructions) ? instructions.trim() : null;
+}
+function applyText(base, change) {
+  if (typeof change === "function") {
+    const value = change(base ?? "");
+    return typeof value === "string" ? value : base;
+  }
+  return typeof change === "string" ? change : base;
+}
+function resolvePrompt(name) {
+  const { prompts, customizations, global } = state();
+  const definition = prompts.get(name);
+  if (!definition) return null;
+  const custom = customizations.get(name) ?? {};
+  if (custom.enabled === false) return null;
+  const system = [applyText(definition.system, custom.system), global.instructions].filter(isText).join("\n\n");
+  return {
+    ...definition,
+    label: custom.label ?? definition.label,
+    heading: custom.heading ?? definition.heading,
+    description: custom.description ?? definition.description,
+    system: system || void 0,
+    instructions: applyText(definition.instructions, custom.instructions) ?? "",
+    customized: Object.keys(custom).length > 0
+  };
+}
+function promptsForTarget(target) {
+  return [...state().prompts.keys()].map(resolvePrompt).filter((prompt) => prompt && prompt.target === target);
+}
+function listPrompts() {
+  const { prompts, customizations } = state();
+  return [...prompts.values()].map((definition) => {
+    var _a, _b;
+    return {
+      name: definition.name,
+      label: ((_a = customizations.get(definition.name)) == null ? void 0 : _a.label) ?? definition.label ?? null,
+      target: definition.target ?? null,
+      mode: definition.mode,
+      source: definition.source,
+      customized: customizations.has(definition.name),
+      enabled: ((_b = customizations.get(definition.name)) == null ? void 0 : _b.enabled) !== false
+    };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+}
+function listUnmatchedCustomizations() {
+  const { prompts, customizations } = state();
+  return [...customizations.keys()].filter((name) => !prompts.has(name)).sort();
+}
+function clearPrompts() {
+  delete globalThis[STATE_KEY];
+}
+export {
+  PROJECT_SOURCE,
+  clearPrompts,
+  configureAi,
+  customizePrompt,
+  definePrompt,
+  listPrompts,
+  listUnmatchedCustomizations,
+  promptsForTarget,
+  resolvePrompt
+};

package/dist/providers/anthropic.server.js

@@ -0,0 +1,42 @@
+import { emptyAnswer, postJson, refusedAnswer, tokens, truncatedAnswer } from "./http.server.js";
+const API_VERSION = "2026-10-21";
+function contentOf(parts) {
+  return parts.map((part) => part.type === "image" ? { type: "image", source: { type: "base64", media_type: part.mimeType, data: part.data } } : { type: "text", text: part.text });
+}
+function anthropicRequest({ model, system, messages, schema, maxTokens }) {
+  return {
+    model,
+    max_tokens: maxTokens,
+    ...system ? { system } : {},
+    messages: messages.map((message) => ({ role: message.role, content: contentOf(message.content) })),
+    output_config: { format: { type: "json_schema", schema } }
+  };
+}
+function anthropicAnswer(body) {
+  var _a, _b, _c, _d;
+  if (body.stop_reason === "refusal") throw refusedAnswer(((_a = body.stop_details) == null ? void 0 : _a.explanation) ?? null);
+  if (body.stop_reason === "max_tokens") throw truncatedAnswer();
+  const text = (_b = (body.content ?? []).find((block) => block.type === "text")) == null ? void 0 : _b.text;
+  if (typeof text !== "string" || text.trim() === "") throw emptyAnswer();
+  return {
+    text,
+    model: typeof body.model === "string" ? body.model : null,
+    usage: {
+      inputTokens: tokens((_c = body.usage) == null ? void 0 : _c.input_tokens),
+      outputTokens: tokens((_d = body.usage) == null ? void 0 : _d.output_tokens)
+    }
+  };
+}
+async function generate(config, request, { signal } = {}) {
+  const body = await postJson(`${config.baseUrl}/v1/messages`, anthropicRequest({ ...request, model: config.model }), {
+    headers: { "x-api-key": config.apiKey, "anthropic-version": API_VERSION },
+    timeoutMs: config.timeoutMs,
+    signal
+  });
+  return anthropicAnswer(body);
+}
+export {
+  anthropicAnswer,
+  anthropicRequest,
+  generate
+};

package/dist/providers/chat-completions.server.js

@@ -0,0 +1,63 @@
+import { emptyAnswer, postJson, refusedAnswer, tokens, truncatedAnswer } from "./http.server.js";
+const DIALECTS = Object.freeze({
+  // OpenAI's reasoning models refuse `max_tokens`: they take
+  // `max_completion_tokens`, which its other models accept too.
+  openai: { imageAsObject: true, strict: true, maxTokensKey: "max_completion_tokens" },
+  mistral: { imageAsObject: false, strict: true, maxTokensKey: "max_tokens" },
+  "openai-compatible": { imageAsObject: true, strict: false, maxTokensKey: "max_tokens" }
+});
+function imagePart(part, dialect) {
+  const url = `data:${part.mimeType};base64,${part.data}`;
+  return { type: "image_url", image_url: dialect.imageAsObject ? { url } : url };
+}
+function contentOf(parts, dialect) {
+  if (parts.every((part) => part.type === "text")) return parts.map((part) => part.text).join("\n\n");
+  return parts.map((part) => part.type === "image" ? imagePart(part, dialect) : { type: "text", text: part.text });
+}
+function chatCompletionsRequest(provider, { model, system, messages, schema, maxTokens }) {
+  const dialect = DIALECTS[provider];
+  return {
+    model,
+    [dialect.maxTokensKey]: maxTokens,
+    messages: [
+      ...system ? [{ role: "system", content: system }] : [],
+      ...messages.map((message) => ({ role: message.role, content: contentOf(message.content, dialect) }))
+    ],
+    response_format: {
+      type: "json_schema",
+      json_schema: { name: "answer", schema, strict: dialect.strict }
+    }
+  };
+}
+function chatCompletionsAnswer(body) {
+  var _a, _b, _c, _d, _e;
+  const choice = (_a = body.choices) == null ? void 0 : _a[0];
+  if (!choice) throw emptyAnswer();
+  if (typeof ((_b = choice.message) == null ? void 0 : _b.refusal) === "string" && choice.message.refusal) throw refusedAnswer(choice.message.refusal);
+  if (choice.finish_reason === "length") throw truncatedAnswer();
+  if (choice.finish_reason === "content_filter") throw refusedAnswer(null);
+  const text = (_c = choice.message) == null ? void 0 : _c.content;
+  if (typeof text !== "string" || text.trim() === "") throw emptyAnswer();
+  return {
+    text,
+    model: typeof body.model === "string" ? body.model : null,
+    usage: {
+      inputTokens: tokens((_d = body.usage) == null ? void 0 : _d.prompt_tokens),
+      outputTokens: tokens((_e = body.usage) == null ? void 0 : _e.completion_tokens)
+    }
+  };
+}
+async function generate(config, request, { signal } = {}) {
+  const body = await postJson(`${config.baseUrl}/chat/completions`, chatCompletionsRequest(config.provider, { ...request, model: config.model }), {
+    headers: config.apiKey ? { authorization: `Bearer ${config.apiKey}` } : {},
+    timeoutMs: config.timeoutMs,
+    signal
+  });
+  return chatCompletionsAnswer(body);
+}
+export {
+  DIALECTS,
+  chatCompletionsAnswer,
+  chatCompletionsRequest,
+  generate
+};

package/dist/providers/google.server.js

@@ -0,0 +1,52 @@
+import { emptyAnswer, postJson, refusedAnswer, tokens, truncatedAnswer } from "./http.server.js";
+function partsOf(parts) {
+  return parts.map((part) => part.type === "image" ? { inlineData: { mimeType: part.mimeType, data: part.data } } : { text: part.text });
+}
+function googleRequest({ system, messages, schema, maxTokens }) {
+  return {
+    ...system ? { systemInstruction: { parts: [{ text: system }] } } : {},
+    contents: messages.map((message) => ({
+      role: message.role === "assistant" ? "model" : "user",
+      parts: partsOf(message.content)
+    })),
+    generationConfig: {
+      responseMimeType: "application/json",
+      responseJsonSchema: schema,
+      maxOutputTokens: maxTokens
+    }
+  };
+}
+function googleAnswer(body) {
+  var _a, _b, _c, _d, _e;
+  if ((_a = body.promptFeedback) == null ? void 0 : _a.blockReason) throw refusedAnswer(body.promptFeedback.blockReason);
+  const candidate = (_b = body.candidates) == null ? void 0 : _b[0];
+  if (!candidate) throw emptyAnswer();
+  if (candidate.finishReason === "MAX_TOKENS") throw truncatedAnswer();
+  if (["SAFETY", "RECITATION", "PROHIBITED_CONTENT", "BLOCKLIST", "SPII"].includes(candidate.finishReason)) {
+    throw refusedAnswer(candidate.finishReason);
+  }
+  const text = (((_c = candidate.content) == null ? void 0 : _c.parts) ?? []).filter((part) => typeof part.text === "string" && !part.thought).map((part) => part.text).join("");
+  if (text.trim() === "") throw emptyAnswer();
+  return {
+    text,
+    model: typeof body.modelVersion === "string" ? body.modelVersion : null,
+    usage: {
+      inputTokens: tokens((_d = body.usageMetadata) == null ? void 0 : _d.promptTokenCount),
+      outputTokens: tokens((_e = body.usageMetadata) == null ? void 0 : _e.candidatesTokenCount)
+    }
+  };
+}
+async function generate(config, request, { signal } = {}) {
+  const url = `${config.baseUrl}/models/${encodeURIComponent(config.model)}:generateContent`;
+  const body = await postJson(url, googleRequest(request), {
+    headers: { "x-goog-api-key": config.apiKey },
+    timeoutMs: config.timeoutMs,
+    signal
+  });
+  return googleAnswer(body);
+}
+export {
+  generate,
+  googleAnswer,
+  googleRequest
+};