a77f3ffb6e
Anti-flash dark (color-scheme + applyDocumentTheme), scroll pages publiques, prompts wizard/slides moins génériques, cron agents rattrapage nextRun null, slides carnet via notebookId, graphiques à 2 crédits + hint, audit dashboard, packs Stripe marqués non configurés sans price ID.
310 lines
10 KiB
TypeScript
310 lines
10 KiB
TypeScript
import { NextRequest, NextResponse } from 'next/server'
|
|
import { auth } from '@/auth'
|
|
import { prisma } from '@/lib/prisma'
|
|
import { QuotaExceededError } from '@/lib/entitlements'
|
|
import { reserveAiUsageOrThrow } from '@/lib/ai-quota'
|
|
import { slideGenerateCreditCost, notebookSlideCreditCost, resolveCreditCost } from '@/lib/credits'
|
|
import type { FeatureName } from '@/lib/quota-utils'
|
|
import { logAuditEvent, getClientIp } from '@/lib/audit-log'
|
|
import {
|
|
encodeSlideIntentDescription,
|
|
normalizeSlideIntent,
|
|
type SlideAudience,
|
|
type SlidePurpose,
|
|
} from '@/lib/ai/services/slide-intent'
|
|
|
|
type GenerateType = 'slide-generator' | 'excalidraw-generator'
|
|
|
|
const TYPE_DEFAULTS: Record<GenerateType, {
|
|
role: string
|
|
tools: string[]
|
|
maxSteps: number
|
|
}> = {
|
|
'slide-generator': {
|
|
// tools unused: slide-generator runs a structured-output pipeline (no function calling)
|
|
role: 'Génère un deck exécutif de haute qualité (titres d\'action, une idée par slide, pas de filler, graphiques uniquement avec vrais chiffres).',
|
|
tools: [],
|
|
maxSteps: 1,
|
|
},
|
|
'excalidraw-generator': {
|
|
role: 'Génère un diagramme Excalidraw clair et professionnel à partir du contenu de la note fournie.',
|
|
tools: ['note_search', 'note_read', 'generate_excalidraw'],
|
|
maxSteps: 6,
|
|
},
|
|
}
|
|
|
|
// ─── POST : kick off generation (fire-and-forget) ──────────────────────────
|
|
export async function POST(req: NextRequest) {
|
|
const session = await auth()
|
|
if (!session?.user?.id) {
|
|
return NextResponse.json({ error: 'Non autorisé' }, { status: 401 })
|
|
}
|
|
const userId = session.user.id
|
|
|
|
const body = await req.json()
|
|
const { noteId, notebookId, type, theme, style, language, template, purpose, audience, slideCount } = body as {
|
|
noteId?: string
|
|
/** Si fourni (slides), génère un deck multi-notes du carnet */
|
|
notebookId?: string
|
|
type: GenerateType
|
|
theme?: string
|
|
style?: string
|
|
language?: string
|
|
template?: string
|
|
purpose?: SlidePurpose
|
|
audience?: SlideAudience
|
|
slideCount?: number
|
|
}
|
|
|
|
if ((!noteId && !notebookId) || !type || !TYPE_DEFAULTS[type]) {
|
|
return NextResponse.json({ error: 'Paramètres invalides' }, { status: 400 })
|
|
}
|
|
if (notebookId && type !== 'slide-generator') {
|
|
return NextResponse.json({ error: 'notebookId réservé aux présentations' }, { status: 400 })
|
|
}
|
|
|
|
let noteCountForPack = 1
|
|
if (notebookId) {
|
|
noteCountForPack = await prisma.note.count({
|
|
where: {
|
|
notebookId,
|
|
userId,
|
|
isArchived: false,
|
|
trashedAt: null,
|
|
},
|
|
})
|
|
if (noteCountForPack < 1) {
|
|
return NextResponse.json({ error: 'Carnet vide ou introuvable' }, { status: 404 })
|
|
}
|
|
}
|
|
|
|
// Crédits globaux (respecte le BYOK) — slides note = 1+N ; carnet = coût notebook
|
|
const featureKey = (type === 'slide-generator' ? 'slide_generate' : 'excalidraw_generate') as FeatureName
|
|
const creditCost =
|
|
type === 'slide-generator'
|
|
? notebookId
|
|
? notebookSlideCreditCost({ slideCount, noteCount: noteCountForPack })
|
|
: slideGenerateCreditCost(slideCount)
|
|
: resolveCreditCost(featureKey)
|
|
try {
|
|
await reserveAiUsageOrThrow(userId, featureKey, {
|
|
amount: creditCost,
|
|
slideCount: type === 'slide-generator' ? slideCount : undefined,
|
|
metadata: {
|
|
noteId: noteId ?? null,
|
|
notebookId: notebookId ?? null,
|
|
type,
|
|
slideCount: slideCount ?? null,
|
|
noteCount: noteCountForPack,
|
|
},
|
|
lane: 'chat',
|
|
})
|
|
} catch (e) {
|
|
if (e instanceof QuotaExceededError) {
|
|
return NextResponse.json(
|
|
{
|
|
error: e.message,
|
|
code: 'QUOTA_EXCEEDED',
|
|
feature: featureKey,
|
|
creditCost,
|
|
},
|
|
{ status: 402 },
|
|
)
|
|
}
|
|
throw e
|
|
}
|
|
|
|
let note: { id: string; title: string | null; notebookId: string | null } | null = null
|
|
if (noteId) {
|
|
note = await prisma.note.findFirst({
|
|
where: { id: noteId, userId },
|
|
select: { id: true, title: true, notebookId: true },
|
|
})
|
|
if (!note) {
|
|
return NextResponse.json({ error: 'Note introuvable' }, { status: 404 })
|
|
}
|
|
} else if (notebookId) {
|
|
const notebook = await prisma.notebook.findFirst({
|
|
where: { id: notebookId, userId },
|
|
select: { id: true, name: true },
|
|
})
|
|
if (!notebook) {
|
|
return NextResponse.json({ error: 'Carnet introuvable' }, { status: 404 })
|
|
}
|
|
note = {
|
|
id: notebookId,
|
|
title: notebook.name,
|
|
notebookId,
|
|
}
|
|
}
|
|
|
|
const defaults = TYPE_DEFAULTS[type]
|
|
const isEn = language === 'English'
|
|
|
|
let role = defaults.role
|
|
if (isEn) {
|
|
if (type === 'slide-generator') {
|
|
const recipeHint = (theme && theme !== 'auto') ? ` Use theme:"${theme}".` : ''
|
|
role = `Generate a high-quality executive deck (action titles, one idea per slide, no filler, charts only with real numbers).${recipeHint}`
|
|
} else {
|
|
role = 'Generate a clear and professional Excalidraw diagram from the provided note content.'
|
|
}
|
|
} else if (type === 'slide-generator') {
|
|
const recipeHint = (theme && theme !== 'auto') ? ` Utilise le thème "${theme}".` : ''
|
|
role = `Génère un deck exécutif de haute qualité (titres d'action, une idée par slide, pas de filler, graphiques uniquement avec vrais chiffres).${recipeHint}`
|
|
}
|
|
|
|
if (!note) {
|
|
return NextResponse.json({ error: 'Source introuvable' }, { status: 404 })
|
|
}
|
|
|
|
const agentName = type === 'slide-generator'
|
|
? `${isEn ? 'Slides' : 'Présentation'} — ${(note.title || 'Note').substring(0, 40)}`
|
|
: `${isEn ? 'Diagram' : 'Diagramme'} — ${(note.title || 'Note').substring(0, 40)}`
|
|
|
|
const slideIntent =
|
|
type === 'slide-generator'
|
|
? normalizeSlideIntent({
|
|
purpose,
|
|
audience,
|
|
slideCount,
|
|
template: template || 'auto',
|
|
})
|
|
: null
|
|
|
|
// Map purpose → legacy template when user picks intent without template
|
|
if (slideIntent && (!slideIntent.template || slideIntent.template === 'auto')) {
|
|
const purposeToTemplate: Record<string, string> = {
|
|
board: 'board-update',
|
|
project: 'project-status',
|
|
strategy: 'strategy-review',
|
|
}
|
|
if (slideIntent.purpose && purposeToTemplate[slideIntent.purpose]) {
|
|
slideIntent.template = purposeToTemplate[slideIntent.purpose]
|
|
}
|
|
}
|
|
|
|
const sourceNotebookId = notebookId || note.notebookId || undefined
|
|
const agent = await prisma.agent.create({
|
|
data: {
|
|
name: agentName,
|
|
type,
|
|
role,
|
|
description:
|
|
type === 'slide-generator' && slideIntent
|
|
? encodeSlideIntentDescription(slideIntent)
|
|
: undefined,
|
|
tools: JSON.stringify(defaults.tools),
|
|
maxSteps: defaults.maxSteps,
|
|
frequency: 'one-shot',
|
|
isEnabled: true,
|
|
sourceNoteIds: noteId ? JSON.stringify([noteId]) : JSON.stringify([]),
|
|
sourceNotebookId: notebookId ? notebookId : undefined,
|
|
targetNotebookId: sourceNotebookId,
|
|
slideTheme: theme ?? 'keynote',
|
|
slideStyle: style ?? 'soft',
|
|
userId,
|
|
},
|
|
})
|
|
|
|
// ── Fire and forget — do NOT await so the HTTP response returns immediately ──
|
|
// In Node.js / Docker self-hosted, the process keeps running after response.
|
|
// skipQuota: units already reserved above (avoids double-charge in executeAgent).
|
|
import('@/lib/ai/services/agent-executor.service')
|
|
.then(({ executeAgent }) => executeAgent(agent.id, userId, undefined, { skipQuota: true }))
|
|
.catch(err => console.error('[run-for-note] Background agent error:', err))
|
|
|
|
logAuditEvent({
|
|
userId,
|
|
action: 'AI_REQUEST',
|
|
resource: featureKey,
|
|
metadata: {
|
|
agentId: agent.id,
|
|
noteId: noteId ?? null,
|
|
notebookId: notebookId ?? null,
|
|
featureKey,
|
|
creditCost,
|
|
},
|
|
ip: getClientIp(req),
|
|
})
|
|
|
|
return NextResponse.json({
|
|
success: true,
|
|
agentId: agent.id,
|
|
status: 'running',
|
|
creditCost,
|
|
})
|
|
}
|
|
|
|
// ─── GET : poll current agent status ──────────────────────────────────────
|
|
export async function GET(req: NextRequest) {
|
|
const session = await auth()
|
|
if (!session?.user?.id) {
|
|
return NextResponse.json({ error: 'Non autorisé' }, { status: 401 })
|
|
}
|
|
const userId = session.user.id
|
|
|
|
const agentId = req.nextUrl.searchParams.get('agentId')
|
|
if (!agentId) {
|
|
return NextResponse.json({ error: 'agentId manquant' }, { status: 400 })
|
|
}
|
|
|
|
// Verify ownership
|
|
const agent = await prisma.agent.findFirst({
|
|
where: { id: agentId, userId },
|
|
select: { id: true },
|
|
})
|
|
if (!agent) {
|
|
return NextResponse.json({ error: 'Agent introuvable' }, { status: 404 })
|
|
}
|
|
|
|
// Return latest action for this agent
|
|
const action = await prisma.agentAction.findFirst({
|
|
where: { agentId },
|
|
orderBy: { createdAt: 'desc' },
|
|
select: { id: true, status: true, result: true, log: true, createdAt: true },
|
|
})
|
|
|
|
if (!action) {
|
|
// Action not created yet (race condition in first poll) — still running
|
|
return NextResponse.json({ status: 'running' })
|
|
}
|
|
|
|
// Detect stale running actions (killed by process restart or hot-reload)
|
|
const GENERATION_TIMEOUT_MS = 8 * 60 * 1000 // 8 minutes
|
|
if (action.status === 'running') {
|
|
const ageMs = Date.now() - new Date(action.createdAt).getTime()
|
|
if (ageMs > GENERATION_TIMEOUT_MS) {
|
|
await prisma.agentAction.update({
|
|
where: { id: action.id },
|
|
data: { status: 'failure', log: 'Generation timed out (process restart)' },
|
|
}).catch(() => { /* best-effort */ })
|
|
return NextResponse.json({ status: 'failure', actionId: action.id, error: 'La génération a expiré. Veuillez réessayer.' })
|
|
}
|
|
}
|
|
|
|
// If success, find canvasId from the related canvas (result stores canvas id)
|
|
let canvasId: string | null = null
|
|
let noteId: string | null = null
|
|
if (action.status === 'success' && action.result) {
|
|
// result field: the executor stores canvas.id or note.id
|
|
const canvas = await prisma.canvas.findFirst({
|
|
where: { id: action.result },
|
|
select: { id: true },
|
|
})
|
|
if (canvas) {
|
|
canvasId = canvas.id
|
|
} else {
|
|
noteId = action.result
|
|
}
|
|
}
|
|
|
|
return NextResponse.json({
|
|
status: action.status, // 'running' | 'success' | 'failure'
|
|
actionId: action.id,
|
|
canvasId,
|
|
noteId,
|
|
error: action.status === 'failure' ? (action.log || 'Erreur inconnue') : undefined,
|
|
})
|
|
}
|