SPB Git

Repository Public

ai.ts 21.8 KB 421 lines typescript

1// SP Mail Next — couche d'intelligence côté client : réglages synchronisés, appels typés de /api/next/ai, mise en forme prudente des2// sorties de modèle (toujours du texte), états d'erreur, file de tri par lots, insertion d'une suggestion dans un brouillon.3import { createStore } from "../state/store"4import { nx, toNextError } from "./api"5import { createCollection } from "./collection"6import type { MessageSummary, Party } from "./types"78// ---------------------------------------------------------------- réglages9export const AI_FEATURES = ["summary", "reply", "write", "triage", "semantic"] as const10export type AiFeature = (typeof AI_FEATURES)[number]11export type AiProviderName = "off" | "local" | "anthropic"12export type AiLanguage = "auto" | "fr" | "en"13export interface AiSettings {14  provider: AiProviderName15  consent_external_at: string | null16  features: Record<AiFeature, boolean>17  language: AiLanguage18  available: { local: boolean; anthropic: boolean; semantic: boolean }19}20export const AI_OFF: AiSettings = {21  provider: "off", consent_external_at: null, language: "auto",22  features: { summary: false, reply: false, write: false, triage: false, semantic: false },23  available: { local: false, anthropic: false, semantic: false },24}25const rec = (v: unknown): Record<string, unknown> => (v && typeof v === "object" && !Array.isArray(v) ? (v as Record<string, unknown>) : {})26const str = (v: unknown, max: number): string => (typeof v === "string" ? v.trim().slice(0, max) : "")27const optStr = (v: unknown, max: number): string | undefined => str(v, max) || undefined28const list = (v: unknown, max: number): unknown[] => (Array.isArray(v) ? v.slice(0, max) : [])2930/** Ne garde d'une réponse que ce qui a la forme attendue ; tout ce qui manque ou surprend vaut « coupé ». Fonction pure. */31export function normalizeSettings(raw: unknown): AiSettings {32  const r = rec(raw)33  const f = rec(r.features)34  const a = rec(r.available)35  const provider: AiProviderName = r.provider === "local" || r.provider === "anthropic" ? r.provider : "off"36  return {37    provider,38    consent_external_at: typeof r.consent_external_at === "string" ? r.consent_external_at : null,39    language: r.language === "fr" || r.language === "en" ? r.language : "auto",40    features: Object.fromEntries(AI_FEATURES.map((k) => [k, f[k] === true])) as Record<AiFeature, boolean>,41    available: { local: a.local === true, anthropic: a.anthropic === true, semantic: a.semantic === true },42  }43}44/** Une fonction n'est proposée que si un fournisseur est choisi, la fonction cochée, et le consentement donné pour un fournisseur externe. */45export function aiOn(s: AiSettings | null | undefined, feature: AiFeature): boolean {46  if (!s || s.provider === "off" || !s.features[feature]) return false47  if (s.provider === "anthropic" && !s.consent_external_at) return false48  return feature !== "semantic" || s.available.semantic49}50export const aiAnyOn = (s: AiSettings | null | undefined): boolean => AI_FEATURES.some((f) => aiOn(s, f))5152/** Collection d'un seul élément : copie IndexedDB, relecture au retour sur l'onglet (web/src/next/collection.ts). */53export const aiSettings = createCollection<AiSettings>("ai-settings", async () => [normalizeSettings(await nx.get<unknown>("ai/settings"))])54/**55 * Réglages confirmés par le serveur ; null tant qu'ils ne le sont pas (une copie en cache ne suffit pas à montrer une surface d'IA :56 * mieux vaut une seconde d'absence qu'un bouton qui survit à une désactivation faite ailleurs).57 */58export function confirmedSettings(s = aiSettings.store.get()): AiSettings | null {59  return s.loaded && !s.stale ? (s.items[0] ?? null) : null60}61export type AiSettingsPatch = { provider?: AiProviderName; features?: Partial<Record<AiFeature, boolean>>; language?: AiLanguage; consent_external?: boolean }62/** Écrit les réglages ; la réponse du serveur (jamais la demande) devient l'état local. */63export async function saveAiSettings(patch: AiSettingsPatch): Promise<AiSettings> {64  const next = normalizeSettings(await nx.put<unknown>("ai/settings", patch))65  aiSettings.mutate(() => [next])66  aiSettings.store.set({ stale: false, error: null })67  return next68}6970// ---------------------------------------------------------------- qui a traité la demande71export interface AiBy {72  provider: string73  model: string74  cached: boolean75}76const byOf = (r: Record<string, unknown>): AiBy => ({ provider: str(r.provider, 60), model: str(r.model, 120), cached: r.cached === true })7778// ---------------------------------------------------------------- résumé79export interface AiSummary extends AiBy {80  summary: string81  decisions: string[]82  action_items: { text: string; owner?: string; due?: string }[]83  deadlines: { text: string; date?: string }[]84  timeline: { at?: string; who?: string; what: string }[]85  language: string86}87/** Forme et plafonds d'un résumé : chaque valeur est une chaîne bornée, le reste est écarté. Fonction pure. */88export function normalizeSummary(raw: unknown): AiSummary {89  const r = rec(raw)90  return {91    ...byOf(r),92    language: str(r.language, 8),93    summary: str(r.summary, 4000),94    decisions: list(r.decisions, 20).map((d) => str(d, 500)).filter(Boolean),95    action_items: list(r.action_items, 30).map((x) => ({ text: str(rec(x).text, 500), owner: optStr(rec(x).owner, 120), due: optStr(rec(x).due, 80) })).filter((x) => x.text),96    deadlines: list(r.deadlines, 20).map((x) => ({ text: str(rec(x).text, 500), date: optStr(rec(x).date, 80) })).filter((x) => x.text),97    timeline: list(r.timeline, 40).map((x) => ({ at: optStr(rec(x).at, 80), who: optStr(rec(x).who, 120), what: str(rec(x).what, 500) })).filter((x) => x.what),98  }99}100export const summaryIsEmpty = (s: AiSummary): boolean => !s.summary && !s.decisions.length && !s.action_items.length && !s.deadlines.length && !s.timeline.length101export async function aiSummarize(mailboxId: string, threadId: string, signal?: AbortSignal): Promise<AiSummary> {102  return normalizeSummary(await nx.post<unknown>("ai/summarize", { mailbox_id: mailboxId, thread_id: threadId }, signal))103}104105// ---------------------------------------------------------------- suggestions de réponse106export const REPLY_TONES = ["concise", "professional", "detailed"] as const107export type ReplyTone = (typeof REPLY_TONES)[number]108export interface AiReplies extends AiBy {109  suggestions: { subject?: string; text: string }[]110  language: string111}112export function normalizeReplies(raw: unknown): AiReplies {113  const r = rec(raw)114  return { ...byOf(r), language: str(r.language, 8), suggestions: list(r.suggestions, 3).map((x) => ({ subject: optStr(rec(x).subject, 200), text: str(rec(x).text, 8000) })).filter((x) => x.text) }115}116export async function aiReplies(i: { mailboxId: string; emailId: string; tone: ReplyTone; language: AiLanguage }, signal?: AbortSignal): Promise<AiReplies> {117  return normalizeReplies(await nx.post<unknown>("ai/replies", { mailbox_id: i.mailboxId, email_id: i.emailId, tone: i.tone, ...(i.language === "auto" ? {} : { language: i.language }) }, signal))118}119120// ---------------------------------------------------------------- aide à la rédaction121export const WRITE_ACTIONS = ["improve", "grammar", "shorten", "expand", "tone", "translate", "subject"] as const122export type WriteAction = (typeof WRITE_ACTIONS)[number]123export const WRITE_TONES = ["concise", "professional", "detailed", "friendly", "formal"] as const124export type WriteTone = (typeof WRITE_TONES)[number]125export const WRITE_LANGS = ["fr", "en", "es", "de", "it", "pt"] as const126export type WriteLang = (typeof WRITE_LANGS)[number]127export const WRITE_MAX = 20_000128export interface AiWriteInput {129  action: WriteAction130  text: string131  tone?: WriteTone132  targetLanguage?: WriteLang133  /** message auquel le brouillon répond (contexte seulement) */134  context?: string135}136export interface AiWriteResult extends AiBy {137  text: string138  subjects: string[]139}140/** Corps de la requête : seules les clés que l'action demande partent ; texte et contexte bornés comme le serveur. Fonction pure. */141export function writeBody(i: AiWriteInput): Record<string, unknown> {142  return {143    action: i.action, text: i.text.trim().slice(0, WRITE_MAX),144    ...(i.action === "tone" ? { tone: i.tone ?? "professional" } : {}),145    ...(i.action === "translate" ? { target_language: i.targetLanguage ?? "en" } : {}),146    ...(i.context?.trim() ? { context: i.context.trim().slice(0, 8000) } : {}),147  }148}149export function normalizeWrite(raw: unknown): AiWriteResult {150  const r = rec(raw)151  return { ...byOf(r), text: typeof r.text === "string" ? r.text.slice(0, 60_000) : "", subjects: list(r.subjects, 5).map((s) => str(s, 200).replace(/[\r\n]+/g, " ")).filter(Boolean) }152}153export async function aiWrite(i: AiWriteInput, signal?: AbortSignal): Promise<AiWriteResult> {154  return normalizeWrite(await nx.post<unknown>("ai/write", writeBody(i), signal))155}156157// ---------------------------------------------------------------- recherche par le sens, index, usage158export interface SemanticInfo {159  backend: string160  model: string161  indexed: number162}163const party = (v: unknown): Party[] => list(v, 50).map((p) => ({ email: str(rec(p).email, 320), name: optStr(rec(p).name, 200) ?? null }))164const strings = (v: unknown, max = 200): string[] => list(v, max).filter((x): x is string => typeof x === "string")165/** Résumé de message rendu par l'IA ou les aperçus de boîte : même forme que la recherche, `folder_roles` en moins. Fonction pure. */166export function normalizeMessage(raw: unknown): MessageSummary | null {167  const r = rec(raw)168  const m: MessageSummary = {169    mailbox_id: str(r.mailbox_id, 64), email_id: str(r.email_id, 255), thread_id: str(r.thread_id, 255), from: party(r.from), to: party(r.to), subject: str(r.subject, 1000), preview: str(r.preview, 1000),170    received_at: str(r.received_at, 40), keywords: strings(r.keywords), mailbox_ids: strings(r.mailbox_ids), has_attachment: r.has_attachment === true, size: Number(r.size) || 0, folder_roles: strings(r.folder_roles),171    ...(typeof r.score === "number" ? { score: r.score } : {}), ...(r.match === "semantic" || r.match === "keyword" || r.match === "both" ? { match: r.match } : {}),172  }173  return m.mailbox_id && m.email_id && m.thread_id ? m : null174}175export async function aiSearch(q: string, mailboxIds: string[] | null, signal?: AbortSignal): Promise<{ data: MessageSummary[]; semantic: SemanticInfo }> {176  const r = rec(await nx.post<unknown>("ai/search", { q, ...(mailboxIds ? { mailboxes: mailboxIds } : {}) }, signal))177  const s = rec(r.semantic)178  return { data: list(r.data, 100).map(normalizeMessage).filter((m): m is MessageSummary => !!m), semantic: { backend: str(s.backend, 60), model: str(s.model, 120), indexed: Number(s.indexed) || 0 } }179}180181export interface IndexStatus {182  enabled: boolean183  available: boolean184  backend: string | null185  model: string | null186  reason: string | null187  indexed: number188  queued: number189  total: number190  last_indexed_at: string | null191  mailboxes: { mailbox_id: string; indexed: number; queued: number; total: number }[]192}193const num = (v: unknown): number => (typeof v === "number" && Number.isFinite(v) && v > 0 ? Math.floor(v) : 0)194export function normalizeIndexStatus(raw: unknown): IndexStatus {195  const r = rec(raw)196  return {197    enabled: r.enabled === true, available: r.available === true, backend: optStr(r.backend, 60) ?? null, model: optStr(r.model, 120) ?? null, reason: optStr(r.reason, 300) ?? null,198    indexed: num(r.indexed), queued: num(r.queued), total: num(r.total), last_indexed_at: typeof r.last_indexed_at === "string" ? r.last_indexed_at : null,199    mailboxes: list(r.mailboxes, 200).map((m) => ({ mailbox_id: str(rec(m).mailbox_id, 64), indexed: num(rec(m).indexed), queued: num(rec(m).queued), total: num(rec(m).total) })).filter((m) => m.mailbox_id),200  }201}202export const aiIndexStatus = async (signal?: AbortSignal): Promise<IndexStatus> => normalizeIndexStatus(await nx.get<unknown>("ai/index/status", undefined, signal))203export const aiIndexRebuild = async (): Promise<number> => num(rec(await nx.post<unknown>("ai/index/rebuild", {})).queued)204205export interface UsageRow {206  day: string207  feature: string208  provider: string209  model: string210  status: string211  requests: number212  input_tokens: number213  output_tokens: number214}215export interface AiUsage {216  rows: UsageRow[]217  limits: { per_minute: number; per_day: number; used_24h: number }218}219export function normalizeUsage(raw: unknown): AiUsage {220  const r = rec(raw)221  const l = rec(r.limits)222  return {223    rows: list(r.data, 500).map((x) => {224      const u = rec(x)225      return { day: str(u.day, 10), feature: str(u.feature, 40), provider: str(u.provider, 60), model: str(u.model, 120), status: str(u.status, 40), requests: num(u.requests), input_tokens: num(u.input_tokens), output_tokens: num(u.output_tokens) }226    }).filter((u) => u.day),227    limits: { per_minute: num(l.per_minute), per_day: num(l.per_day), used_24h: num(l.used_24h) },228  }229}230export const aiUsage = async (days = 30, signal?: AbortSignal): Promise<AiUsage> => normalizeUsage(await nx.get<unknown>("ai/usage", { days }, signal))231232// ---------------------------------------------------------------- erreurs → état d'interface233/** Ce qu'un panneau d'IA dit quand une demande n'aboutit pas : une ligne, précise, avec ou sans « Réessayer ». */234export type AiIssue = "offline" | "disabled" | "consent" | "unavailable" | "rate_limited" | "timeout" | "invalid_output" | "refused" | "not_found" | "error"235export interface AiFailure {236  issue: AiIssue237  /** une nouvelle tentative a du sens (panne passagère, débit, sortie invalide) */238  retry: boolean239  /** les réglages ont probablement changé ailleurs : à relire */240  resync: boolean241}242/** Classe un échec d'une route d'IA d'après le code du serveur d'abord, puis la famille d'erreur. Fonction pure. */243export function aiFailure(e: unknown): AiFailure {244  const err = toNextError(e)245  const f = (issue: AiIssue, retry: boolean, resync = false): AiFailure => ({ issue, retry, resync })246  if (err.kind === "offline") return f("offline", true)247  if (err.kind === "ai_disabled") return f("disabled", false, true)248  if (err.kind === "consent_required") return f("consent", false, true)249  if (err.kind === "provider_unavailable") return f("unavailable", false, true)250  if (err.code === "ai_timeout" || err.status === 504) return f("timeout", true)251  if (err.code === "ai_invalid_output" || err.code === "ai_output_truncated") return f("invalid_output", true)252  if (err.code === "ai_refused") return f("refused", false)253  if (err.kind === "rate_limited") return f("rate_limited", true)254  if (err.kind === "not_found") return f("not_found", false)255  if (err.kind === "unavailable") return f("unavailable", true)256  return f("error", true)257}258259// ---------------------------------------------------------------- tri par lots260export const TRIAGE_CATEGORIES = ["personal", "work", "newsletter", "notification", "transaction", "social", "other"] as const261export type TriageCategory = (typeof TRIAGE_CATEGORIES)[number]262export interface TriageEntry {263  category: TriageCategory264  needs_action: boolean265  important: boolean266  reason: string267}268export interface TriageBatch extends AiBy {269  items: Map<string, TriageEntry>270}271export function normalizeTriage(raw: unknown): TriageBatch {272  const r = rec(raw)273  const items = new Map<string, TriageEntry>()274  for (const x of list(r.data, 25)) {275    const i = rec(x)276    const id = str(i.email_id, 255)277    const category = (TRIAGE_CATEGORIES as readonly string[]).includes(String(i.category)) ? (i.category as TriageCategory) : "other"278    if (id) items.set(id, { category, needs_action: i.needs_action === true, important: i.important === true, reason: str(i.reason, 300) })279  }280  return { ...byOf(r), items }281}282export const TRIAGE_MAX = 25283export async function aiTriage(mailboxId: string, emailIds: string[]): Promise<TriageBatch> {284  return normalizeTriage(await nx.post<unknown>("ai/triage", { mailbox_id: mailboxId, email_ids: emailIds.slice(0, TRIAGE_MAX) }))285}286287export interface TriageQueue {288  /** résultat connu, sinon `undefined` et le message rejoint le prochain lot */289  want: (mailboxId: string, emailId: string) => TriageEntry | undefined290  peek: (emailId: string) => TriageEntry | undefined291  /** fournisseur et modèle du dernier lot traité */292  by: () => AiBy | null293  /** envoie tout de suite ce qui attend (tests, retour au premier plan) */294  flush: () => Promise<void>295  clear: () => void296}297/**298 * File du tri : les messages demandés (lignes visibles) sont regroupés après `delay` ms, par boîte et par lots de 25 au plus,299 * un lot à la fois ; les résultats restent en mémoire par identifiant ; un échec est silencieux et le message n'est pas300 * redemandé avant `clear()`. Rien ici ne bloque la liste.301 */302export function createTriageQueue(o: { fetch: (mailboxId: string, ids: string[]) => Promise<TriageBatch>; onUpdate: () => void; delay?: number; max?: number; schedule?: (fn: () => void, ms: number) => () => void }): TriageQueue {303  const max = Math.min(TRIAGE_MAX, o.max ?? TRIAGE_MAX)304  const schedule = o.schedule ?? ((fn, ms) => { const h = setTimeout(fn, ms); return () => clearTimeout(h) })305  const known = new Map<string, TriageEntry>()306  const waiting = new Map<string, string>() // identifiant → boîte307  const busy = new Set<string>()308  const failed = new Set<string>()309  let by: AiBy | null = null310  let cancel: (() => void) | null = null311  let running: Promise<void> | null = null312  let gen = 0313  const run = async () => {314    const my = gen315    while (waiting.size && my === gen) {316      const [, mailboxId] = waiting.entries().next().value as [string, string]317      const ids = [...waiting].filter(([, mb]) => mb === mailboxId).map(([id]) => id).slice(0, max)318      for (const id of ids) { waiting.delete(id); busy.add(id) }319      try {320        const r = await o.fetch(mailboxId, ids)321        if (my !== gen) return322        for (const id of ids) {323          const e = r.items.get(id)324          if (e) known.set(id, e); else failed.add(id)325        }326        by = { provider: r.provider, model: r.model, cached: false }327        o.onUpdate()328      } catch {329        if (my !== gen) return330        // silencieux : pas de pastille pour ces messages, et pas de nouvelle demande en boucle331        for (const id of ids) failed.add(id)332      } finally {333        for (const id of ids) busy.delete(id)334      }335    }336  }337  const flush = (): Promise<void> => {338    cancel?.()339    cancel = null340    running ??= run().finally(() => { running = null })341    return running342  }343  return {344    want(mailboxId, emailId) {345      const hit = known.get(emailId)346      if (hit) return hit347      if (!mailboxId || busy.has(emailId) || failed.has(emailId) || waiting.has(emailId)) return undefined348      waiting.set(emailId, mailboxId)349      cancel?.()350      cancel = schedule(() => { cancel = null; void flush() }, o.delay ?? 600)351      return undefined352    },353    peek: (emailId) => known.get(emailId),354    by: () => by,355    flush,356    clear() {357      gen++358      cancel?.()359      cancel = null360      known.clear(); waiting.clear(); busy.clear(); failed.clear()361      by = null362    },363  }364}365366// ---------------------------------------------------------------- suggestion → brouillon367/**368 * HTML d'un texte de modèle pour l'éditeur : un bloc par ligne, construit avec des nœuds de texte (jamais d'analyse de balisage) —369 * `<img onerror>`, `<script>` ou un lien Markdown restent des caractères. `doc` : document de travail (détaché de la page).370 */371export function textToDraftHtml(text: string, doc: Document): string {372  const box = doc.createElement("div")373  for (const line of text.replace(/\r\n?/g, "\n").split("\n")) {374    const div = doc.createElement("div")375    if (line === "") div.appendChild(doc.createElement("br"))376    else div.textContent = line377    box.appendChild(div)378  }379  // sérialisation de nœuds que nous venons de créer : la seule lecture d'innerHTML du module, aucune écriture380  return box.innerHTML381}382/** Place une suggestion au-dessus de ce que le brouillon contient déjà (ligne vide, signature, message cité). Fonction pure. */383export function insertSuggestion(draft: { html: string; text: string }, suggestion: string, doc: Document): { html: string; text: string } {384  const clean = suggestion.replace(/\r\n?/g, "\n").trim()385  return { html: textToDraftHtml(clean, doc) + draft.html, text: `${clean}\n${draft.text.startsWith("\n") ? "" : "\n"}${draft.text}` }386}387388// ---------------------------------------------------------------- rappel depuis une action du résumé389export const REMINDER_PRESETS = ["tomorrow", "in3days", "nextWeek"] as const390export type ReminderPreset = (typeof REMINDER_PRESETS)[number]391/** Échéance d'un préréglage, à 9 h heure locale : demain, dans 3 jours, lundi prochain (toujours dans le futur). Fonction pure. */392export function reminderDue(preset: ReminderPreset, now = new Date()): Date {393  const d = new Date(now)394  d.setHours(9, 0, 0, 0)395  if (preset === "tomorrow") d.setDate(d.getDate() + 1)396  else if (preset === "in3days") d.setDate(d.getDate() + 3)397  else d.setDate(d.getDate() + (((8 - d.getDay()) % 7) || 7))398  return d399}400export interface Reminder {401  id: string402  email_id: string403  due_at: string404  note: string | null405}406export async function createReminder(i: { mailboxId: string; emailId: string; due: Date; note: string }): Promise<Reminder> {407  return nx.post<Reminder>("reminders", { mailbox_id: i.mailboxId, email_id: i.emailId, due_at: i.due.toISOString(), note: i.note.trim().slice(0, 500) })408}409410// ---------------------------------------------------------------- état partagé des surfaces (module ↔ panneaux)411/** `summaryAsk` : la palette demande un résumé du fil ouvert ; `triageRev` : un lot de tri est arrivé (les lignes se redessinent). */412export const aiUi = createStore<{ summaryAsk: number; triageRev: number; triageBy: AiBy | null }>({ summaryAsk: 0, triageRev: 0, triageBy: null })413export const triageQueue: TriageQueue = createTriageQueue({414  fetch: aiTriage,415  onUpdate: () => aiUi.set((s) => ({ triageRev: s.triageRev + 1, triageBy: triageQueue.by() })),416})417export function resetTriage() {418  triageQueue.clear()419  aiUi.set((s) => ({ triageRev: s.triageRev + 1, triageBy: null }))420}421
Files main
Menu

Theme