@fraza/module-ai 0.0.0-stage → 0.4.22

package/dist/providers/http.server.js

@@ -0,0 +1,98 @@
+const MAX_DETAIL = 300;
+class AiProviderError extends Error {
+  constructor(code, message, { status = null, detail = null, cause } = {}) {
+    super(message, cause ? { cause } : void 0);
+    this.name = "AiProviderError";
+    this.code = code;
+    this.status = status;
+    this.detail = detail;
+  }
+  /** A later attempt may succeed: a durable subscriber retries on these. */
+  get retryable() {
+    return ["timeout", "unreachable", "rate_limited", "provider"].includes(this.code);
+  }
+}
+function trimDetail(text) {
+  if (typeof text !== "string" || text === "") return null;
+  return text.length > MAX_DETAIL ? `${text.slice(0, MAX_DETAIL)}\u2026` : text;
+}
+function providerMessage(body) {
+  if (!body || typeof body !== "object") return null;
+  const error = body.error;
+  if (typeof error === "string") return error;
+  if (error && typeof error.message === "string") return error.message;
+  if (typeof body.message === "string") return body.message;
+  if (typeof body.detail === "string") return body.detail;
+  return null;
+}
+function errorForStatus(status, detail) {
+  if (status === 401 || status === 403) {
+    return new AiProviderError("auth", "Le fournisseur refuse la cl\xE9 d'API. V\xE9rifier FRAZA_MODULE_AI_API_KEY.", { status, detail });
+  }
+  if (status === 429) {
+    return new AiProviderError("rate_limited", "Le fournisseur limite les appels pour l'instant. R\xE9essayer dans un moment.", { status, detail });
+  }
+  if (status >= 500) {
+    return new AiProviderError("provider", "Le fournisseur n'a pas pu r\xE9pondre. R\xE9essayer plus tard.", { status, detail });
+  }
+  return new AiProviderError("rejected", "Le fournisseur refuse la demande. V\xE9rifier le mod\xE8le et la configuration.", { status, detail });
+}
+async function readBody(response) {
+  const text = await response.text();
+  try {
+    return { json: JSON.parse(text), text };
+  } catch {
+    return { json: null, text };
+  }
+}
+async function postJson(url, body, { headers = {}, timeoutMs, signal } = {}) {
+  const timeout = AbortSignal.timeout(timeoutMs);
+  const combined = signal ? AbortSignal.any([signal, timeout]) : timeout;
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...headers },
+      body: JSON.stringify(body),
+      signal: combined
+    });
+  } catch (err) {
+    if (signal == null ? void 0 : signal.aborted) throw new AiProviderError("cancelled", "L'appel a \xE9t\xE9 annul\xE9.", { cause: err });
+    if (timeout.aborted) throw new AiProviderError("timeout", "Le fournisseur n'a pas r\xE9pondu \xE0 temps.", { cause: err });
+    throw new AiProviderError("unreachable", "Le fournisseur est injoignable. V\xE9rifier l'adresse et le r\xE9seau.", { cause: err });
+  }
+  let parsed;
+  try {
+    parsed = await readBody(response);
+  } catch (err) {
+    if (timeout.aborted) throw new AiProviderError("timeout", "Le fournisseur n'a pas r\xE9pondu \xE0 temps.", { cause: err });
+    throw new AiProviderError("provider", "La r\xE9ponse du fournisseur n'a pas pu \xEAtre lue.", { cause: err });
+  }
+  if (!response.ok) {
+    throw errorForStatus(response.status, trimDetail(providerMessage(parsed.json) ?? parsed.text));
+  }
+  if (!parsed.json || typeof parsed.json !== "object") {
+    throw new AiProviderError("provider", "La r\xE9ponse du fournisseur n'est pas du JSON.", { status: response.status });
+  }
+  return parsed.json;
+}
+function emptyAnswer() {
+  return new AiProviderError("provider", "Le fournisseur a r\xE9pondu sans contenu.");
+}
+function truncatedAnswer() {
+  return new AiProviderError("truncated", "La r\xE9ponse a \xE9t\xE9 coup\xE9e : elle d\xE9passe la limite de jetons du prompt.");
+}
+function refusedAnswer(detail = null) {
+  return new AiProviderError("refused", "Le mod\xE8le a refus\xE9 de r\xE9pondre \xE0 cette demande.", { detail: trimDetail(detail) });
+}
+function tokens(value) {
+  return Number.isInteger(value) && value >= 0 ? value : null;
+}
+export {
+  AiProviderError,
+  emptyAnswer,
+  postJson,
+  refusedAnswer,
+  tokens,
+  truncatedAnswer
+};

package/dist/providers/index.server.js

@@ -0,0 +1,22 @@
+import { generate as anthropic } from "./anthropic.server.js";
+import { generate as chatCompletions } from "./chat-completions.server.js";
+import { generate as google } from "./google.server.js";
+import { generate as ollama } from "./ollama.server.js";
+const GENERATORS = Object.freeze({
+  anthropic,
+  openai: chatCompletions,
+  mistral: chatCompletions,
+  "openai-compatible": chatCompletions,
+  google,
+  ollama
+});
+function generatorFor(provider) {
+  const generate = GENERATORS[provider];
+  if (!generate) throw new TypeError(`No AI provider named ${JSON.stringify(provider)}`);
+  return generate;
+}
+import { AiProviderError } from "./http.server.js";
+export {
+  AiProviderError,
+  generatorFor
+};

package/dist/providers/ollama.server.js

@@ -0,0 +1,45 @@
+import { emptyAnswer, postJson, tokens, truncatedAnswer } from "./http.server.js";
+function messageOf(message) {
+  const text = message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n\n");
+  const images = message.content.filter((part) => part.type === "image").map((part) => part.data);
+  return { role: message.role, content: text, ...images.length > 0 ? { images } : {} };
+}
+function ollamaRequest({ model, system, messages, schema, maxTokens }) {
+  return {
+    model,
+    stream: false,
+    messages: [
+      ...system ? [{ role: "system", content: system }] : [],
+      ...messages.map(messageOf)
+    ],
+    format: schema,
+    options: { num_predict: maxTokens }
+  };
+}
+function ollamaAnswer(body) {
+  var _a;
+  if (body.done_reason === "length") throw truncatedAnswer();
+  const text = (_a = body.message) == null ? void 0 : _a.content;
+  if (typeof text !== "string" || text.trim() === "") throw emptyAnswer();
+  return {
+    text,
+    model: typeof body.model === "string" ? body.model : null,
+    usage: {
+      inputTokens: tokens(body.prompt_eval_count),
+      outputTokens: tokens(body.eval_count)
+    }
+  };
+}
+async function generate(config, request, { signal } = {}) {
+  const body = await postJson(`${config.baseUrl}/api/chat`, ollamaRequest({ ...request, model: config.model }), {
+    headers: config.apiKey ? { authorization: `Bearer ${config.apiKey}` } : {},
+    timeoutMs: config.timeoutMs,
+    signal
+  });
+  return ollamaAnswer(body);
+}
+export {
+  generate,
+  ollamaAnswer,
+  ollamaRequest
+};

package/dist/register-server.js

@@ -0,0 +1,34 @@
+import { registerApiRoutes } from "@fraza/core/api";
+import { registerNavItem, registerPageMeta } from "@fraza/core/features/admin";
+import { registerRateLimitPreset } from "@fraza/core/shared/rate-limit";
+import { routes, RUN_RATE_LIMIT } from "./api.server.js";
+import { isAiEnabled } from "./config.server.js";
+import { registerCronJobs } from "./cron.server.js";
+import { provideAiIntegration } from "./integration.server.js";
+import { AI_PERMISSIONS } from "./permissions.js";
+import { SOURCE } from "./source.js";
+import { defineTestPrompt } from "./test-prompt.server.js";
+import { registerWidgetFetchers } from "./widgets.server.js";
+if (isAiEnabled()) {
+  provideAiIntegration();
+  defineTestPrompt();
+  registerNavItem({
+    id: "ai",
+    label: "IA",
+    icon: "BrainIcon",
+    href: "ai",
+    sectionId: "platform",
+    order: 30,
+    permission: AI_PERMISSIONS.VIEW
+  }, { source: SOURCE });
+  registerPageMeta({
+    slug: "ai",
+    title: "IA",
+    description: "Fournisseur d'IA, prompts, historique des appels et jetons consomm\xE9s",
+    permission: AI_PERMISSIONS.VIEW
+  }, { source: SOURCE });
+  registerRateLimitPreset(RUN_RATE_LIMIT, { maxAttempts: 10, windowMs: 10 * 6e4, blockMs: 10 * 6e4 });
+  registerApiRoutes(routes, { source: SOURCE });
+  registerWidgetFetchers();
+  await registerCronJobs();
+}

package/dist/results.server.js

@@ -0,0 +1,74 @@
+import { deleteInBatches, query, queryAll, queryOne } from "@fraza/core/database";
+const TARGET_PATTERN = /^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)*$/;
+const MAX_ID = 120;
+function checkTarget(target, id) {
+  if (typeof target !== "string" || !TARGET_PATTERN.test(target) || target.length > 120) {
+    throw new TypeError(`AI results: the target must be lowercase words, e.g. 'medias.media' (got ${JSON.stringify(target)})`);
+  }
+  const text = typeof id === "number" && Number.isSafeInteger(id) ? String(id) : id;
+  if (typeof text !== "string" || text === "" || text.length > MAX_ID) {
+    throw new TypeError("AI results: the id must be an integer or a string of at most 120 characters");
+  }
+  return text;
+}
+function toResult(row) {
+  return {
+    id: String(row.id),
+    target: row.target_type,
+    targetId: row.target_id,
+    prompt: row.prompt,
+    data: row.data,
+    model: row.model,
+    createdAt: row.updated_at instanceof Date ? row.updated_at.toISOString() : row.updated_at
+  };
+}
+async function saveResult({ target, id, prompt, data, model = null }) {
+  const targetId = checkTarget(target, id);
+  if (typeof prompt !== "string" || prompt === "") throw new TypeError("saveResult: the prompt is required");
+  if (!data || typeof data !== "object") throw new TypeError("saveResult: data must be the answer, an object");
+  const row = await queryOne(
+    `INSERT INTO fraza_ai_result (target_type, target_id, prompt, data, model)
+     VALUES ($1, $2, $3, $4::jsonb, $5)
+     ON CONFLICT (target_type, target_id, prompt)
+     DO UPDATE SET data = EXCLUDED.data, model = EXCLUDED.model, updated_at = now(), dismissed_at = NULL
+     RETURNING *`,
+    [target, targetId, prompt, JSON.stringify(data), model]
+  );
+  return toResult(row);
+}
+async function getResults(target, id) {
+  const targetId = checkTarget(target, id);
+  const rows = await queryAll(
+    `SELECT * FROM fraza_ai_result
+      WHERE target_type = $1 AND target_id = $2 AND dismissed_at IS NULL
+      ORDER BY updated_at DESC`,
+    [target, targetId]
+  );
+  return rows.map(toResult);
+}
+async function dismissResult(resultId) {
+  if (!/^\d{1,18}$/.test(String(resultId))) return false;
+  const { rowCount } = await query(
+    `UPDATE fraza_ai_result SET dismissed_at = now() WHERE id = $1 AND dismissed_at IS NULL`,
+    [String(resultId)]
+  );
+  return rowCount > 0;
+}
+async function deleteResults(target, id) {
+  const targetId = checkTarget(target, id);
+  const { rowCount } = await query(
+    `DELETE FROM fraza_ai_result WHERE target_type = $1 AND target_id = $2`,
+    [target, targetId]
+  );
+  return rowCount;
+}
+async function purgeDismissedResults({ days, signal }) {
+  return deleteInBatches("fraza_ai_result", "dismissed_at < now() - make_interval(days => $1)", [days], { signal });
+}
+export {
+  deleteResults,
+  dismissResult,
+  getResults,
+  purgeDismissedResults,
+  saveResult
+};

package/dist/run.server.js

@@ -0,0 +1,166 @@
+import { fail } from "@fraza/core/shared/logger";
+import { AiConfigError, getAiConfig, isAiEnabled } from "./config.server.js";
+import { resolvePrompt } from "./prompts.server.js";
+import { AiProviderError, generatorFor } from "./providers/index.server.js";
+import { recordRun } from "./runs.server.js";
+import { checkSchema, normalizeForProvider, validate } from "./schema.js";
+import { hasHtmlField, planOutput, readTurn, studioFollowUp, studioOutput } from "./studio.js";
+const TRIGGERS = /* @__PURE__ */ new Set(["button", "code", "test"]);
+const IMAGE_TYPES = /* @__PURE__ */ new Set(["image/png", "image/jpeg", "image/webp", "image/gif"]);
+const MAX_IMAGE_CHARS = 20 * 1024 * 1024;
+function failure(code, message, retryable = false) {
+  return { success: false, error: { code, message, retryable } };
+}
+function readParts(built) {
+  if (typeof built === "string") return [{ type: "text", text: built }];
+  if (!Array.isArray(built) || built.length === 0) throw new TypeError("build() must return a string or an array of parts");
+  return built.map((part, index) => {
+    if ((part == null ? void 0 : part.type) === "text" && typeof part.text === "string") return { type: "text", text: part.text };
+    if ((part == null ? void 0 : part.type) === "image") {
+      if (!IMAGE_TYPES.has(part.mimeType)) throw new TypeError(`build(): part ${index} is an image of an unsupported type (${part.mimeType})`);
+      if (typeof part.data !== "string" || part.data === "" || part.data.length > MAX_IMAGE_CHARS) {
+        throw new TypeError(`build(): part ${index} needs its data in base64, 20 MB at most`);
+      }
+      return { type: "image", mimeType: part.mimeType, data: part.data };
+    }
+    throw new TypeError(`build(): part ${index} must be { type: 'text', text } or { type: 'image', data, mimeType }`);
+  });
+}
+function parseAnswer(text) {
+  const unfenced = text.trim().replace(/^```(?:json)?\s*([\s\S]*?)\s*```$/, "$1");
+  try {
+    return { value: JSON.parse(unfenced), problems: [] };
+  } catch {
+    return { value: null, problems: ["$: the answer is not valid JSON"] };
+  }
+}
+function addUsage(total, usage) {
+  const add = (a, b) => a === null && b === null ? null : (a ?? 0) + (b ?? 0);
+  return {
+    inputTokens: add(total.inputTokens, usage.inputTokens),
+    outputTokens: add(total.outputTokens, usage.outputTokens)
+  };
+}
+function retryMessage(problems) {
+  return {
+    role: "user",
+    content: [{
+      type: "text",
+      text: `Your answer does not match the expected JSON schema:
+- ${problems.slice(0, 20).join("\n- ")}
+Answer again with the corrected JSON only.`
+    }]
+  };
+}
+async function callUntilValid(config, request, schema, signal) {
+  const generate = generatorFor(config.provider);
+  let messages = request.messages;
+  let usage = { inputTokens: null, outputTokens: null };
+  let model = null;
+  for (let attempt = 1; attempt <= 2; attempt += 1) {
+    const answer = await generate(config, { ...request, messages }, { signal });
+    usage = addUsage(usage, answer.usage);
+    model = answer.model ?? model;
+    const { value, problems } = parseAnswer(answer.text);
+    const issues = problems.length > 0 ? problems : validate(schema, value);
+    if (issues.length === 0) return { data: value, usage, model, attempts: attempt };
+    if (attempt === 2) return { data: null, usage, model, attempts: attempt, problems: issues };
+    messages = [...messages, { role: "assistant", content: [{ type: "text", text: answer.text }] }, retryMessage(issues)];
+  }
+  throw new Error("unreachable");
+}
+async function writeHistory(run) {
+  try {
+    await recordRun(run);
+  } catch (err) {
+    fail(`AI: the call of ${run.prompt} could not be written to the history`, err);
+  }
+}
+async function outputSchemaOf(prompt, scope) {
+  const schema = typeof prompt.output === "function" ? await prompt.output(scope) : prompt.output;
+  if (schema === null) return null;
+  checkSchema(schema, `${prompt.name}.output`);
+  return schema;
+}
+async function prepare(prompt, { input, context, scope, turn }) {
+  if (prompt.input) {
+    const problems = validate(prompt.input, input ?? null);
+    if (problems.length > 0) return { failure: failure("invalid_input", "Les donn\xE9es envoy\xE9es au prompt sont invalides.") };
+  }
+  try {
+    const schema = await outputSchemaOf(prompt, scope);
+    if (schema === null) return { failure: failure("not_applicable", "Ce prompt ne s'applique pas \xE0 ce contenu.") };
+    const parts = readParts(await prompt.build({ input: input ?? null, context: context ?? null, scope, instructions: prompt.instructions }));
+    if (prompt.mode === "studio") {
+      if (turn.phase === "plan" && !hasHtmlField(schema)) {
+        return { failure: failure("invalid_input", "Ce prompt n'a pas de contenu \xE0 structurer : pas de plan.") };
+      }
+      const answer = turn.phase === "plan" ? planOutput() : studioOutput(schema, turn.variants);
+      return { schema: answer, parts: [...parts, { type: "text", text: studioFollowUp(turn) }] };
+    }
+    return { schema, parts };
+  } catch (err) {
+    fail(`AI: the prompt ${prompt.name} could not be prepared`, err);
+    return { failure: failure("prompt_error", "Le prompt n'a pas pu \xEAtre pr\xE9par\xE9. Le d\xE9tail est dans le journal du serveur.") };
+  }
+}
+async function runPrompt(name, { input, context, scope = {}, turn, userId = null, trigger = "code", signal } = {}) {
+  if (!isAiEnabled()) return failure("not_configured", "Le module IA est d\xE9sactiv\xE9 : FRAZA_MODULE_AI ne vaut pas true.");
+  const prompt = resolvePrompt(name);
+  if (!prompt) return failure("unknown_prompt", "Ce prompt n'existe pas ou a \xE9t\xE9 d\xE9sactiv\xE9.");
+  let config;
+  try {
+    config = getAiConfig();
+  } catch (err) {
+    if (err instanceof AiConfigError) return failure("not_configured", `L'IA n'est pas configur\xE9e : ${err.message}`);
+    throw err;
+  }
+  const checkedTurn = prompt.mode === "studio" ? readTurn(turn ?? {}) : null;
+  if (prompt.mode === "studio" && !checkedTurn) return failure("invalid_input", "Le tour du studio est invalide : asks, previous, variants, phase ou plan.");
+  const prepared = await prepare(prompt, { input, context, scope: scope ?? {}, turn: checkedTurn });
+  if (prepared.failure) return prepared.failure;
+  const request = {
+    system: prompt.system,
+    messages: [{ role: "user", content: prepared.parts }],
+    schema: normalizeForProvider(prepared.schema, config.provider),
+    maxTokens: prompt.maxTokens
+  };
+  const run = {
+    prompt: prompt.name,
+    source: prompt.source,
+    trigger: TRIGGERS.has(trigger) ? trigger : "code",
+    provider: config.provider,
+    model: config.model,
+    userId
+  };
+  const started = Date.now();
+  try {
+    const result = await callUntilValid(config, request, prepared.schema, signal);
+    const durationMs = Date.now() - started;
+    const model = result.model ?? config.model;
+    if (result.problems) {
+      await writeHistory({
+        ...run,
+        ...result.usage,
+        model,
+        durationMs,
+        attempts: result.attempts,
+        status: "error",
+        errorCode: "invalid_answer",
+        errorMessage: `R\xE9ponse hors sch\xE9ma : ${result.problems.slice(0, 5).join(" ; ")}`
+      });
+      return failure("invalid_answer", "La r\xE9ponse de l'IA ne correspond pas \xE0 la forme attendue. R\xE9essayer.", true);
+    }
+    await writeHistory({ ...run, ...result.usage, model, durationMs, attempts: result.attempts, status: "success" });
+    return { success: true, data: result.data, model, usage: result.usage };
+  } catch (err) {
+    if (!(err instanceof AiProviderError)) throw err;
+    const errorMessage = err.detail && err.code !== "refused" ? `${err.message} (${err.detail})` : err.message;
+    await writeHistory({ ...run, durationMs: Date.now() - started, status: "error", errorCode: err.code, errorMessage });
+    return failure(err.code, err.message, err.retryable);
+  }
+}
+export {
+  outputSchemaOf,
+  runPrompt
+};

package/dist/runs.server.js

@@ -0,0 +1,106 @@
+import { deleteInBatches, query, queryAll, queryOne } from "@fraza/core/database";
+const MAX_ERROR = 500;
+function clip(text, max) {
+  if (typeof text !== "string") return null;
+  return text.length > max ? `${text.slice(0, max)}\u2026` : text;
+}
+async function recordRun(run) {
+  await query(
+    `INSERT INTO fraza_ai_run
+       (prompt, source, trigger, provider, model, status, error_code, error_message,
+        input_tokens, output_tokens, attempts, duration_ms, user_id)
+     VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)`,
+    [
+      clip(run.prompt, 120),
+      clip(run.source, 214),
+      run.trigger,
+      run.provider,
+      clip(run.model, 200),
+      run.status,
+      run.errorCode ?? null,
+      clip(run.errorMessage, MAX_ERROR),
+      run.inputTokens ?? null,
+      run.outputTokens ?? null,
+      run.attempts ?? 1,
+      run.durationMs ?? null,
+      run.userId ?? null
+    ]
+  );
+}
+function toRun(row) {
+  return {
+    id: String(row.id),
+    prompt: row.prompt,
+    source: row.source,
+    trigger: row.trigger,
+    provider: row.provider,
+    model: row.model,
+    status: row.status,
+    errorCode: row.error_code,
+    errorMessage: row.error_message,
+    inputTokens: row.input_tokens,
+    outputTokens: row.output_tokens,
+    attempts: row.attempts,
+    durationMs: row.duration_ms,
+    createdAt: row.created_at instanceof Date ? row.created_at.toISOString() : row.created_at
+  };
+}
+async function listRuns({ limit, offset, status = null }) {
+  const where = status ? "WHERE status = $1" : "";
+  const params = status ? [status] : [];
+  const total = await queryOne(`SELECT count(*)::int AS n FROM fraza_ai_run ${where}`, params);
+  const rows = await queryAll(
+    `SELECT * FROM fraza_ai_run ${where} ORDER BY created_at DESC, id DESC
+      LIMIT $${params.length + 1} OFFSET $${params.length + 2}`,
+    [...params, limit, offset]
+  );
+  return { runs: rows.map(toRun), total: (total == null ? void 0 : total.n) ?? 0 };
+}
+function checkRange(from, to) {
+  if (!(from instanceof Date) || Number.isNaN(from.getTime()) || !(to instanceof Date) || Number.isNaN(to.getTime())) {
+    throw new TypeError("getUsage: from and to must be dates");
+  }
+  if (from > to) throw new TypeError("getUsage: from is after to");
+}
+async function getUsage({ from, to }) {
+  checkRange(from, to);
+  const params = [from, to];
+  const range = "created_at >= $1 AND created_at < $2";
+  const byTokens = "coalesce(sum(input_tokens), 0) + coalesce(sum(output_tokens), 0) DESC";
+  const sums = `count(*)::int AS calls,
+    count(*) FILTER (WHERE status = 'error')::int AS errors,
+    coalesce(sum(input_tokens), 0)::bigint AS input_tokens,
+    coalesce(sum(output_tokens), 0)::bigint AS output_tokens`;
+  const [totals, byDay, byPrompt, byModel] = await Promise.all([
+    queryOne(`SELECT ${sums} FROM fraza_ai_run WHERE ${range}`, params),
+    queryAll(`SELECT to_char(created_at AT TIME ZONE 'UTC', 'YYYY-MM-DD') AS day, ${sums}
+                FROM fraza_ai_run WHERE ${range} GROUP BY day ORDER BY day`, params),
+    queryAll(`SELECT prompt, ${sums} FROM fraza_ai_run WHERE ${range}
+               GROUP BY prompt ORDER BY ${byTokens}, prompt`, params),
+    queryAll(`SELECT provider, model, ${sums} FROM fraza_ai_run WHERE ${range}
+               GROUP BY provider, model ORDER BY ${byTokens}, model`, params)
+  ]);
+  const counts = (row) => ({
+    calls: (row == null ? void 0 : row.calls) ?? 0,
+    errors: (row == null ? void 0 : row.errors) ?? 0,
+    inputTokens: Number((row == null ? void 0 : row.input_tokens) ?? 0),
+    outputTokens: Number((row == null ? void 0 : row.output_tokens) ?? 0)
+  });
+  return {
+    from: from.toISOString(),
+    to: to.toISOString(),
+    totals: counts(totals),
+    byDay: byDay.map((row) => ({ day: row.day, ...counts(row) })),
+    byPrompt: byPrompt.map((row) => ({ prompt: row.prompt, ...counts(row) })),
+    byModel: byModel.map((row) => ({ provider: row.provider, model: row.model, ...counts(row) }))
+  };
+}
+async function purgeRuns({ days, signal }) {
+  return deleteInBatches("fraza_ai_run", "created_at < now() - make_interval(days => $1)", [days], { signal });
+}
+export {
+  getUsage,
+  listRuns,
+  purgeRuns,
+  recordRun
+};