Repository Public
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