@fraza/module-ai 0.0.0-stage → 0.4.23

package/dist/admin/input-form.js

@@ -0,0 +1,59 @@
+const ONE_LINE_MAX = 120;
+function typesOf(node) {
+  return Array.isArray(node.type) ? node.type : [node.type];
+}
+function formFields(schema) {
+  if (!(schema == null ? void 0 : schema.properties)) return [];
+  return Object.entries(schema.properties).map(([key, node]) => {
+    const types = typesOf(node);
+    const type = types.find((t) => t !== "null");
+    const kind = type === "boolean" ? "boolean" : type === "number" || type === "integer" ? "number" : node.enum ? "select" : node.maxLength && node.maxLength <= ONE_LINE_MAX ? "line" : "text";
+    return {
+      key,
+      kind,
+      label: node.title ?? key,
+      description: node.description ?? null,
+      required: !types.includes("null") && kind !== "boolean",
+      options: node.enum ?? [],
+      maxLength: node.maxLength ?? null,
+      integer: type === "integer"
+    };
+  });
+}
+function initialValues(fields) {
+  return Object.fromEntries(fields.map((field) => [field.key, field.kind === "boolean" ? false : ""]));
+}
+function readValues(fields, values) {
+  const input = {};
+  const errors = {};
+  for (const field of fields) {
+    const raw = values[field.key];
+    if (field.kind === "boolean") {
+      input[field.key] = Boolean(raw);
+      continue;
+    }
+    const text = typeof raw === "string" ? raw.trim() : "";
+    if (text === "") {
+      if (field.required) errors[field.key] = "Ce champ est requis.";
+      else input[field.key] = null;
+      continue;
+    }
+    if (field.kind === "number") {
+      const number = Number(text.replace(",", "."));
+      if (!Number.isFinite(number) || field.integer && !Number.isInteger(number)) errors[field.key] = field.integer ? "Un nombre entier est attendu." : "Un nombre est attendu.";
+      else input[field.key] = number;
+      continue;
+    }
+    if (field.maxLength && [...text].length > field.maxLength) {
+      errors[field.key] = `${field.maxLength} caract\xE8res au plus.`;
+      continue;
+    }
+    input[field.key] = text;
+  }
+  return { input, errors };
+}
+export {
+  formFields,
+  initialValues,
+  readValues
+};

package/dist/admin/paths.js

@@ -0,0 +1,4 @@
+const AI_API = "/za/api/ai";
+export {
+  AI_API
+};

package/dist/admin/studio-compose.js

@@ -0,0 +1,94 @@
+const WORK_WORDS = Object.freeze({
+  write: Object.freeze(["Esquisse", "Premier jet", "Intertitres", "Mise en forme", "Transitions", "Exemples", "Fil conducteur", "Chapeau", "D\xE9veloppement", "Mise en mots"]),
+  rework: Object.freeze(["Relecture", "Peaufinage", "Accords", "Ponctuation", "Tournures", "Nuances", "Rythme", "Clart\xE9", "Reformulation", "Polissage", "Liaisons", "V\xE9rification", "Synonymes", "Ciselage"]),
+  plan: Object.freeze(["Structure", "Angle", "Sections", "Titres", "Ordre", "Fil conducteur", "\xC9quilibre", "Charpente"])
+});
+function hasValue(value) {
+  if (Array.isArray(value)) return value.length > 0;
+  if (typeof value === "string") return value.replace(/<[^>]+>/g, "").trim() !== "";
+  return value !== null && value !== void 0;
+}
+function isEmptyValues(fields, values) {
+  const texts = fields.filter((field) => field.kind === "text");
+  if (texts.length === 0) return false;
+  return texts.every((field) => !hasValue(values == null ? void 0 : values[field.key]));
+}
+function mergeVersion(fields, values, version) {
+  const out = { ...values };
+  for (const field of fields) {
+    const next = version == null ? void 0 : version[field.key];
+    if (next !== null && next !== void 0) out[field.key] = next;
+  }
+  return out;
+}
+function firstRequest(text, hints, ticked) {
+  const on = new Set(ticked);
+  const lines = hints.filter((hint) => on.has(hint.label)).map((hint) => `- ${hint.text}`);
+  const head = text.trim();
+  if (lines.length === 0) return head;
+  return [head, "", "Consignes :", ...lines].join("\n").trim();
+}
+function groupHints(hints) {
+  const groups = /* @__PURE__ */ new Map();
+  const alone = [];
+  for (const hint of hints) {
+    if (!hint.group) {
+      alone.push(hint);
+      continue;
+    }
+    if (!groups.has(hint.group)) groups.set(hint.group, { name: hint.group, hints: [] });
+    groups.get(hint.group).hints.push(hint);
+  }
+  return { groups: [...groups.values()], alone };
+}
+function layoutFields(fields) {
+  const title = fields.find((field) => field.kind === "text" && !field.html) ?? null;
+  const page = fields.filter((field) => field.html);
+  const sheet = fields.filter((field) => field !== title && !field.html);
+  return { title, page, sheet };
+}
+function planOf(answer, titleIndex = 0) {
+  const titles = Array.isArray(answer == null ? void 0 : answer.titles) ? answer.titles : [];
+  return {
+    titles,
+    title: titles[titleIndex] ?? titles[0] ?? "",
+    sections: ((answer == null ? void 0 : answer.sections) ?? []).map((section) => ({ title: section.title, summary: section.summary ?? "" }))
+  };
+}
+function planToSend(plan) {
+  return {
+    title: plan.title ?? "",
+    sections: plan.sections.filter((section) => section.title.trim()).map((section) => ({ title: section.title.trim(), summary: section.summary.trim() }))
+  };
+}
+function moveSection(plan, index, delta) {
+  const to = index + delta;
+  if (to < 0 || to >= plan.sections.length) return plan;
+  const sections = [...plan.sections];
+  [sections[index], sections[to]] = [sections[to], sections[index]];
+  return { ...plan, sections };
+}
+function removeSection(plan, index) {
+  return { ...plan, sections: plan.sections.filter((_, i) => i !== index) };
+}
+function addSection(plan) {
+  return { ...plan, sections: [...plan.sections, { title: "", summary: "" }] };
+}
+function renameSection(plan, index, changes) {
+  return { ...plan, sections: plan.sections.map((section, i) => i === index ? { ...section, ...changes } : section) };
+}
+export {
+  WORK_WORDS,
+  addSection,
+  firstRequest,
+  groupHints,
+  hasValue,
+  isEmptyValues,
+  layoutFields,
+  mergeVersion,
+  moveSection,
+  planOf,
+  planToSend,
+  removeSection,
+  renameSection
+};

package/dist/admin/studio-diff.js

@@ -0,0 +1,240 @@
+const DIFF_LIMIT = 25e4;
+const BLOCK_TAGS = "p|h[1-6]|ul|ol|blockquote|pre|figure|div|table";
+const OPEN_RE = new RegExp(`<(${BLOCK_TAGS}|hr)\\b[^>]*>`, "gi");
+const HAS_BLOCK = new RegExp(`<(${BLOCK_TAGS}|li)\\b`, "i");
+const MARKER = /^\s*\[\[bloc:[^\]\s]+\]\]\s*$/;
+const ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: "\xA0", "#39": "'" };
+function decode(text) {
+  return text.replace(/&(#\d+|#x[0-9a-f]+|[a-z]+\d*);/gi, (all, name) => {
+    if (name[0] === "#") {
+      const code = name[1] === "x" || name[1] === "X" ? parseInt(name.slice(2), 16) : parseInt(name.slice(1), 10);
+      return Number.isFinite(code) ? String.fromCodePoint(code) : all;
+    }
+    return ENTITIES[name.toLowerCase()] ?? all;
+  });
+}
+function htmlText(html) {
+  return decode(html.replace(/<\/(li|p|h[1-6])>/gi, "\n").replace(/<br\s*\/?>/gi, "\n").replace(/<[^>]+>/g, "")).replace(/[ \t]+\n/g, "\n").replace(/\n{2,}/g, "\n").trim();
+}
+function isHtml(value) {
+  return typeof value === "string" && HAS_BLOCK.test(value);
+}
+function htmlBlocks(html) {
+  const source = String(html ?? "");
+  const out = [];
+  const push = (piece, tag) => {
+    const text = htmlText(piece);
+    if (!text && tag !== "hr" && tag !== "figure") return;
+    out.push({ html: piece.trim(), tag, text, marker: MARKER.test(text) });
+  };
+  let last = 0;
+  OPEN_RE.lastIndex = 0;
+  let open;
+  while ((open = OPEN_RE.exec(source)) !== null) {
+    const tag = open[1].toLowerCase();
+    const between = source.slice(last, open.index);
+    if (between.trim()) push(`<p>${between.trim()}</p>`, "p");
+    const end = tag === "hr" ? OPEN_RE.lastIndex : closingEnd(source, tag, OPEN_RE.lastIndex);
+    push(source.slice(open.index, end), tag);
+    last = end;
+    OPEN_RE.lastIndex = end;
+  }
+  const rest = source.slice(last);
+  if (rest.trim()) push(`<p>${rest.trim()}</p>`, "p");
+  return out;
+}
+function closingEnd(source, tag, from) {
+  const re = new RegExp(`<(/?)${tag}\\b[^>]*>`, "gi");
+  re.lastIndex = from;
+  let depth = 1;
+  let match;
+  while ((match = re.exec(source)) !== null) {
+    depth += match[1] ? -1 : 1;
+    if (depth === 0) return re.lastIndex;
+  }
+  return source.length;
+}
+function tokens(text) {
+  return text.split(/(\s+)/).filter((token) => token !== "");
+}
+function lcsTable(a, b, same) {
+  const table = Array.from({ length: a.length + 1 }, () => new Uint32Array(b.length + 1));
+  for (let i = a.length - 1; i >= 0; i -= 1) {
+    for (let j = b.length - 1; j >= 0; j -= 1) {
+      table[i][j] = same(a[i], b[j]) ? table[i + 1][j + 1] + 1 : Math.max(table[i + 1][j], table[i][j + 1]);
+    }
+  }
+  return table;
+}
+function compact(segments) {
+  const out = [];
+  for (const [kind, text] of segments) {
+    const last = out[out.length - 1];
+    if (last && last[0] === kind) last[1] += text;
+    else out.push([kind, text]);
+  }
+  return out;
+}
+function wordDiff(before, after) {
+  const a = tokens(before ?? "");
+  const b = tokens(after ?? "");
+  if (a.length * b.length > DIFF_LIMIT) return compact([["del", before ?? ""], ["add", after ?? ""]].filter(([, t]) => t));
+  const table = lcsTable(a, b, (x, y) => x === y);
+  const out = [];
+  let i = 0;
+  let j = 0;
+  while (i < a.length && j < b.length) {
+    if (a[i] === b[j]) {
+      out.push(["same", a[i]]);
+      i += 1;
+      j += 1;
+    } else if (table[i + 1][j] >= table[i][j + 1]) {
+      out.push(["del", a[i]]);
+      i += 1;
+    } else {
+      out.push(["add", b[j]]);
+      j += 1;
+    }
+  }
+  while (i < a.length) out.push(["del", a[i++]]);
+  while (j < b.length) out.push(["add", b[j++]]);
+  return regions(out);
+}
+function regions(raw) {
+  const out = [];
+  let i = 0;
+  while (i < raw.length) {
+    if (raw[i][0] === "same") {
+      out.push(raw[i]);
+      i += 1;
+      continue;
+    }
+    let end = i;
+    for (let k = i; k < raw.length; k += 1) {
+      const [kind, text] = raw[k];
+      if (kind !== "same") {
+        end = k;
+        continue;
+      }
+      if (text.trim()) break;
+    }
+    let del = "";
+    let add = "";
+    for (let k = i; k <= end; k += 1) {
+      const [kind, text] = raw[k];
+      if (kind !== "add") del += text;
+      if (kind !== "del") add += text;
+    }
+    if (del) out.push(["del", del]);
+    if (add) out.push(["add", add]);
+    i = end + 1;
+  }
+  return compact(out);
+}
+function alignBlocks(before, after) {
+  const table = lcsTable(before, after, (x, y) => x.text === y.text);
+  const pairs = [];
+  let i = 0;
+  let j = 0;
+  const gapBefore = [];
+  const gapAfter = [];
+  const flush = () => {
+    const count = Math.max(gapBefore.length, gapAfter.length);
+    for (let k = 0; k < count; k += 1) {
+      const b = gapBefore[k] ?? null;
+      const a = gapAfter[k] ?? null;
+      pairs.push({ kind: b && a ? "change" : b ? "del" : "add", before: b, after: a });
+    }
+    gapBefore.length = 0;
+    gapAfter.length = 0;
+  };
+  while (i < before.length && j < after.length) {
+    if (before[i].text === after[j].text) {
+      flush();
+      pairs.push({ kind: "same", before: before[i], after: after[j] });
+      i += 1;
+      j += 1;
+    } else if (table[i + 1][j] >= table[i][j + 1]) {
+      gapBefore.push(before[i++]);
+    } else {
+      gapAfter.push(after[j++]);
+    }
+  }
+  while (i < before.length) gapBefore.push(before[i++]);
+  while (j < after.length) gapAfter.push(after[j++]);
+  flush();
+  return pairs;
+}
+function fieldsOf(output) {
+  return Object.entries((output == null ? void 0 : output.properties) ?? {}).map(([key, node]) => {
+    var _a;
+    const types = [node.type].flat();
+    const kind = types.includes("array") ? "list" : node.enum ? "choice" : "text";
+    const options = kind === "list" ? ((_a = node.items) == null ? void 0 : _a.enum) ?? null : node.enum ?? null;
+    return { key, label: node.title ?? key, kind, html: node.format === "html", options, maxLength: node.maxLength ?? null };
+  });
+}
+function sameValue(a, b) {
+  return JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+}
+function listText(value) {
+  if (Array.isArray(value)) return value.join(", ");
+  return value === null || value === void 0 ? "" : String(value);
+}
+function compareField(field, now, next) {
+  const unchanged = next === null || next === void 0 || sameValue(now, next);
+  if (field.kind === "text" && (isHtml(now) || isHtml(next))) {
+    const before = htmlBlocks(typeof now === "string" ? now : "");
+    const after = unchanged ? before : htmlBlocks(next);
+    const pieces = alignBlocks(before, after).map((pair, index) => {
+      const block = pair.after ?? pair.before;
+      const segments2 = pair.kind === "same" ? [["same", block.text]] : pair.kind === "add" ? [["add", pair.after.text]] : pair.kind === "del" ? [["del", pair.before.text]] : wordDiff(pair.before.text, pair.after.text);
+      return { id: `${field.key}.${index}`, kind: pair.kind, tag: block.tag, marker: block.marker, before: pair.before, after: pair.after, segments: segments2 };
+    });
+    return { html: true, changed: pieces.some((piece) => piece.kind !== "same"), pieces };
+  }
+  const text = field.kind === "text" ? now ?? "" : listText(now);
+  if (unchanged) {
+    return { html: false, changed: false, pieces: [{ id: field.key, kind: "same", segments: text ? [["same", text]] : [] }] };
+  }
+  const segments = field.kind === "text" ? wordDiff(String(now ?? ""), String(next)) : compact([["del", text], ["add", listText(next)]].filter(([, t]) => t));
+  return { html: false, changed: true, pieces: [{ id: field.key, kind: "change", segments, value: next }] };
+}
+function mergeField(compared, kept) {
+  if (!compared.changed) return void 0;
+  const isKept = (piece) => kept[piece.id] !== false;
+  if (!compared.pieces.some((piece) => piece.kind !== "same" && isKept(piece))) return void 0;
+  if (!compared.html) return compared.pieces[0].value;
+  return compared.pieces.map((piece) => {
+    if (piece.kind === "same") return piece.before.html;
+    if (piece.kind === "change") return isKept(piece) ? piece.after.html : piece.before.html;
+    if (piece.kind === "add") return isKept(piece) ? piece.after.html : "";
+    return isKept(piece) ? "" : piece.before.html;
+  }).filter(Boolean).join("\n");
+}
+function compareVersion(fields, current, version, kept) {
+  const compared = {};
+  const changes = [];
+  const merged = {};
+  for (const field of fields) {
+    const result = compareField(field, current == null ? void 0 : current[field.key], version == null ? void 0 : version[field.key]);
+    compared[field.key] = result;
+    for (const piece of result.pieces) {
+      if (piece.kind !== "same") changes.push({ ...piece, field });
+    }
+    const value = mergeField(result, kept);
+    if (value !== void 0) merged[field.key] = value;
+  }
+  return { compared, changes, merged };
+}
+export {
+  alignBlocks,
+  compareField,
+  compareVersion,
+  fieldsOf,
+  htmlBlocks,
+  htmlText,
+  isHtml,
+  mergeField,
+  wordDiff
+};

package/dist/admin/widgets.js

@@ -0,0 +1,14 @@
+import { AI_PERMISSIONS } from "../permissions.js";
+const AI_WIDGETS = Object.freeze({
+  USAGE: Object.freeze({
+    id: "ai-usage",
+    title: "IA",
+    description: "Les jetons consomm\xE9s ce mois-ci et les appels en \xE9chec.",
+    permission: AI_PERMISSIONS.VIEW,
+    size: { default: 1, min: 1, max: 2 },
+    order: 80
+  })
+});
+export {
+  AI_WIDGETS
+};

package/dist/admin.js

@@ -0,0 +1,9 @@
+"use client";
+import { registerPage } from "@fraza/core/features/admin";
+import { provideIntegration } from "@fraza/core/integrations";
+import AiActions from "./admin/AiActions.client.js";
+import AiResults from "./admin/AiResults.client.js";
+import "./admin/AiUsageWidget.client.js";
+import { SOURCE } from "./source.js";
+registerPage({ slug: "ai", load: () => import("./admin/AiPage.client.js") }, { source: SOURCE });
+provideIntegration("ai", { AiActions, AiResults }, { source: SOURCE });

package/dist/api.server.js

@@ -0,0 +1,155 @@
+import { apiError, apiSuccess, defineApiRoutes, readJsonObject } from "@fraza/core/api";
+import { parsePagination } from "@fraza/core/database/sql";
+import { fail } from "@fraza/core/shared/logger";
+import { hasPermission } from "@fraza/core/users";
+import { describeAiConfig } from "./config.server.js";
+import { AI_PERMISSIONS } from "./permissions.js";
+import { listPrompts, listUnmatchedCustomizations, promptsForTarget, resolvePrompt } from "./prompts.server.js";
+import { dismissResult, getResults } from "./results.server.js";
+import { outputSchemaOf, runPrompt } from "./run.server.js";
+import { getUsage, listRuns } from "./runs.server.js";
+import { readTurn } from "./studio.js";
+import { TEST_PROMPT } from "./test-prompt.server.js";
+const RUN_RATE_LIMIT = "ai_run";
+const NAME_PATTERN = /^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)*$/;
+const RUNS_PAGE = { defaultLimit: 50, max: 200 };
+const USAGE_DAYS = { default: 30, max: 366 };
+const DAY_MS = 24 * 60 * 60 * 1e3;
+const FAILURE_STATUS = {
+  unknown_prompt: 404,
+  invalid_input: 400,
+  not_applicable: 400,
+  not_configured: 503,
+  prompt_error: 500,
+  rate_limited: 429,
+  cancelled: 400
+};
+function readScope(url) {
+  const raw = url.searchParams.get("scope");
+  if (!raw) return {};
+  try {
+    const scope = JSON.parse(raw);
+    return scope && typeof scope === "object" && !Array.isArray(scope) ? scope : null;
+  } catch {
+    return null;
+  }
+}
+async function mayRun(prompt, userId) {
+  return !prompt.permission || hasPermission(userId, prompt.permission);
+}
+async function handleActions(request, params, context) {
+  const url = new URL(request.url);
+  const target = url.searchParams.get("target") ?? "";
+  if (!NAME_PATTERN.test(target)) return apiError("Bad Request", "\xC9cran inconnu.");
+  const scope = readScope(url);
+  if (scope === null) return apiError("Bad Request", "Param\xE8tre scope invalide.");
+  const userId = context.session.user.id;
+  const actions = [];
+  for (const prompt of promptsForTarget(target)) {
+    if (!await mayRun(prompt, userId)) continue;
+    let output;
+    try {
+      output = await outputSchemaOf(prompt, scope);
+    } catch (err) {
+      fail(`AI: the output schema of ${prompt.name} could not be built`, err);
+      continue;
+    }
+    if (output === null) continue;
+    actions.push({
+      name: prompt.name,
+      label: prompt.label,
+      heading: prompt.heading ?? null,
+      description: prompt.description ?? null,
+      mode: prompt.mode,
+      input: prompt.input ?? null,
+      output,
+      suggestions: prompt.suggestions ?? [],
+      hints: prompt.hints ?? []
+    });
+  }
+  return apiSuccess({ actions, configured: describeAiConfig().configured });
+}
+function failureResponse(error) {
+  const status = FAILURE_STATUS[error.code] ?? 502;
+  return apiError(status, error.message, { code: error.code });
+}
+async function handleRun(request, params, context) {
+  const body = await readJsonObject(request);
+  const prompt = typeof body.prompt === "string" ? resolvePrompt(body.prompt) : null;
+  if (!prompt || !prompt.target) return apiError("Not Found", "Ce prompt n'existe pas ou a \xE9t\xE9 d\xE9sactiv\xE9.");
+  const userId = context.session.user.id;
+  if (!await mayRun(prompt, userId)) return apiError("Forbidden", "Ce prompt demande une permission que ce compte n'a pas.");
+  const scope = body.scope ?? {};
+  if (typeof scope !== "object" || Array.isArray(scope)) return apiError("Bad Request", "Param\xE8tre scope invalide.");
+  const turn = prompt.mode === "studio" ? readTurn(body.turn ?? {}) : void 0;
+  if (turn === null) return apiError("Bad Request", "Param\xE8tre turn invalide.");
+  const result = await runPrompt(prompt.name, {
+    input: body.input ?? null,
+    context: body.context ?? null,
+    scope,
+    turn,
+    userId,
+    trigger: "button",
+    signal: request.signal
+  });
+  if (!result.success) return failureResponse(result.error);
+  return apiSuccess({ success: true, data: result.data, model: result.model });
+}
+async function handleResults(request) {
+  const url = new URL(request.url);
+  const target = url.searchParams.get("target") ?? "";
+  const id = url.searchParams.get("id") ?? "";
+  if (!NAME_PATTERN.test(target) || id === "" || id.length > 120) return apiError("Bad Request", "Contenu inconnu.");
+  return apiSuccess({ results: await getResults(target, id) });
+}
+async function handleDismiss(request, params) {
+  if (!await dismissResult(params.id)) return apiError("Not Found", "Cette proposition n'existe plus.");
+  return apiSuccess({ success: true });
+}
+async function handleStatus() {
+  return apiSuccess({
+    config: describeAiConfig(),
+    prompts: listPrompts().filter((prompt) => prompt.name !== TEST_PROMPT),
+    unmatchedCustomizations: listUnmatchedCustomizations()
+  });
+}
+async function handleTest(request, params, context) {
+  const result = await runPrompt(TEST_PROMPT, { userId: context.session.user.id, trigger: "test", signal: request.signal });
+  if (!result.success) return failureResponse(result.error);
+  return apiSuccess({ success: true, model: result.model, usage: result.usage, data: result.data });
+}
+async function handleRuns(request) {
+  const url = new URL(request.url);
+  const status = url.searchParams.get("status") || null;
+  if (status && status !== "success" && status !== "error") return apiError("Bad Request", "Statut invalide.");
+  const { page, limit, offset } = parsePagination(url, RUNS_PAGE);
+  const { runs, total } = await listRuns({ limit, offset, status });
+  return apiSuccess({ runs, pagination: { page, limit, total } });
+}
+async function handleUsage(request) {
+  const raw = new URL(request.url).searchParams.get("days");
+  const days = raw === null ? USAGE_DAYS.default : Number(raw);
+  if (!Number.isInteger(days) || days < 1 || days > USAGE_DAYS.max) {
+    return apiError("Bad Request", `La p\xE9riode doit compter de 1 \xE0 ${USAGE_DAYS.max} jours.`);
+  }
+  const to = /* @__PURE__ */ new Date();
+  const from = new Date(to.getTime() - days * DAY_MS);
+  return apiSuccess({ usage: await getUsage({ from, to }) });
+}
+const use = { auth: "admin", permission: AI_PERMISSIONS.USE };
+const view = { auth: "admin", permission: AI_PERMISSIONS.VIEW };
+const routes = defineApiRoutes([
+  { path: "/ai/actions", method: "GET", handler: handleActions, ...use },
+  // Each run costs tokens: its own budget, counted per account.
+  { path: "/ai/run", method: "POST", handler: handleRun, ...use, rateLimit: RUN_RATE_LIMIT },
+  { path: "/ai/results", method: "GET", handler: handleResults, ...use },
+  { path: "/ai/results/:id/dismiss", method: "POST", handler: handleDismiss, ...use },
+  { path: "/ai/status", method: "GET", handler: handleStatus, ...view },
+  { path: "/ai/test", method: "POST", handler: handleTest, ...view, rateLimit: RUN_RATE_LIMIT },
+  { path: "/ai/runs", method: "GET", handler: handleRuns, ...view },
+  { path: "/ai/usage", method: "GET", handler: handleUsage, ...view }
+]);
+export {
+  RUN_RATE_LIMIT,
+  routes
+};