@lastbrain/ai-ui-core 1.0.28 → 1.0.30

package/dist/client/lb-client.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Client LastBrain intelligent
+ * Supporte deux modes d'authentification :
+ * - env-key : utilise LB_API_KEY (côté serveur)
+ * - session : utilise cookie lb_session (user authentifié)
+ */
+import type { LBAuthConfig, LBSession, LBLoginResult, LBApiKey, LBSessionResult } from "../types/auth";
+export declare class LBClient {
+    private config;
+    constructor(config?: LBAuthConfig);
+    /**
+     * Détecte le mode d'authentification à utiliser
+     */
+    private getAuthMode;
+    /**
+     * Construit les headers d'authentification
+     */
+    private getAuthHeaders;
+    /**
+     * Fait une requête à l'API LastBrain
+     */
+    private request;
+    /**
+     * Login utilisateur (email + password)
+     * Retourne un access_token temporaire pour récupérer les clés API
+     */
+    login(email: string, password: string): Promise<LBLoginResult>;
+    /**
+     * Récupère les clés API de l'utilisateur
+     */
+    getUserApiKeys(accessToken: string): Promise<LBApiKey[]>;
+    /**
+     * Crée une session (72h) avec une clé API sélectionnée
+     */
+    createSession(accessToken: string, apiKeyId: string): Promise<LBSessionResult>;
+    /**
+     * Vérifie si une session est valide
+     */
+    verifySession(sessionToken: string): Promise<LBSession | null>;
+    /**
+     * Déconnexion (invalide la session)
+     */
+    logout(sessionToken: string): Promise<void>;
+    /**
+     * Fait un appel IA (génération de texte)
+     */
+    generateText(params: {
+        prompt: string;
+        model?: string;
+        sessionToken?: string;
+        [key: string]: any;
+    }): Promise<any>;
+    /**
+     * Fait un appel IA (génération d'image)
+     */
+    generateImage(params: {
+        prompt: string;
+        model?: string;
+        sessionToken?: string;
+        [key: string]: any;
+    }): Promise<any>;
+}
+/**
+ * Factory pour créer un client LastBrain
+ */
+export declare function createLBClient(config?: LBAuthConfig): LBClient;
+//# sourceMappingURL=lb-client.d.ts.map

package/dist/client/lb-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lb-client.d.ts","sourceRoot":"","sources":["../../src/client/lb-client.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,SAAS,EAET,aAAa,EACb,QAAQ,EACR,eAAe,EAChB,MAAM,eAAe,CAAC;AAEvB,qBAAa,QAAQ;IACnB,OAAO,CAAC,MAAM,CAAyB;gBAE3B,MAAM,GAAE,YAAiB;IAWrC;;OAEG;IACH,OAAO,CAAC,WAAW;IAQnB;;OAEG;YACW,cAAc;IAsB5B;;OAEG;YACW,OAAO;IAyCrB;;;OAGG;IACG,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAOpE;;OAEG;IACG,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;IAQ9D;;OAEG;IACG,aAAa,CACjB,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,eAAe,CAAC;IAU3B;;OAEG;IACG,aAAa,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;IAYpE;;OAEG;IACG,MAAM,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASjD;;OAEG;IACG,YAAY,CAAC,MAAM,EAAE;QACzB,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;KACpB,GAAG,OAAO,CAAC,GAAG,CAAC;IAWhB;;OAEG;IACG,aAAa,CAAC,MAAM,EAAE;QAC1B,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;KACpB,GAAG,OAAO,CAAC,GAAG,CAAC;CAUjB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,CAAC,EAAE,YAAY,GAAG,QAAQ,CAE9D"}

package/dist/client/lb-client.js

@@ -0,0 +1,168 @@
+/**
+ * Client LastBrain intelligent
+ * Supporte deux modes d'authentification :
+ * - env-key : utilise LB_API_KEY (côté serveur)
+ * - session : utilise cookie lb_session (user authentifié)
+ */
+export class LBClient {
+    config;
+    constructor(config = {}) {
+        this.config = {
+            baseUrl: config.baseUrl ||
+                process.env.LB_BASE_URL ||
+                "https://prompt.lastbrain.io",
+            apiKey: config.apiKey || process.env.LB_API_KEY || "",
+            mode: config.mode || "auto",
+        };
+    }
+    /**
+     * Détecte le mode d'authentification à utiliser
+     */
+    getAuthMode() {
+        if (this.config.mode === "env-key")
+            return "env-key";
+        if (this.config.mode === "session")
+            return "session";
+        // Mode auto : préfère env-key si disponible
+        return this.config.apiKey ? "env-key" : "session";
+    }
+    /**
+     * Construit les headers d'authentification
+     */
+    async getAuthHeaders(sessionToken) {
+        const mode = this.getAuthMode();
+        if (mode === "env-key" && this.config.apiKey) {
+            return {
+                Authorization: `Bearer ${this.config.apiKey}`,
+            };
+        }
+        // Mode session : utilise le token fourni ou tente de lire le cookie
+        if (sessionToken) {
+            return {
+                Authorization: `Bearer ${sessionToken}`,
+            };
+        }
+        // Si aucun token fourni, la requête échouera (attendu pour déclencher auth)
+        return {};
+    }
+    /**
+     * Fait une requête à l'API LastBrain
+     */
+    async request(endpoint, options = {}) {
+        const { baseUrl, headers: customHeaders, timeout, ...fetchOptions } = options;
+        const url = `${baseUrl || this.config.baseUrl}${endpoint}`;
+        const authHeaders = await this.getAuthHeaders();
+        const controller = new AbortController();
+        const timeoutId = timeout
+            ? setTimeout(() => controller.abort(), timeout)
+            : undefined;
+        try {
+            const response = await fetch(url, {
+                ...fetchOptions,
+                headers: {
+                    "Content-Type": "application/json",
+                    ...authHeaders,
+                    ...customHeaders,
+                },
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                const error = await response.json().catch(() => ({}));
+                throw new Error(error.message || `HTTP ${response.status}`);
+            }
+            return await response.json();
+        }
+        finally {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+        }
+    }
+    /**
+     * Login utilisateur (email + password)
+     * Retourne un access_token temporaire pour récupérer les clés API
+     */
+    async login(email, password) {
+        return this.request("/auth/login", {
+            method: "POST",
+            body: JSON.stringify({ email, password }),
+        });
+    }
+    /**
+     * Récupère les clés API de l'utilisateur
+     */
+    async getUserApiKeys(accessToken) {
+        return this.request("/user/api-keys", {
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+            },
+        });
+    }
+    /**
+     * Crée une session (72h) avec une clé API sélectionnée
+     */
+    async createSession(accessToken, apiKeyId) {
+        return this.request("/auth/session", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+            },
+            body: JSON.stringify({ api_key_id: apiKeyId }),
+        });
+    }
+    /**
+     * Vérifie si une session est valide
+     */
+    async verifySession(sessionToken) {
+        try {
+            return await this.request("/auth/session/verify", {
+                headers: {
+                    Authorization: `Bearer ${sessionToken}`,
+                },
+            });
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Déconnexion (invalide la session)
+     */
+    async logout(sessionToken) {
+        await this.request("/auth/session/logout", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${sessionToken}`,
+            },
+        });
+    }
+    /**
+     * Fait un appel IA (génération de texte)
+     */
+    async generateText(params) {
+        const { sessionToken, ...body } = params;
+        const headers = await this.getAuthHeaders(sessionToken);
+        return this.request("/ai/generate-text", {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+        });
+    }
+    /**
+     * Fait un appel IA (génération d'image)
+     */
+    async generateImage(params) {
+        const { sessionToken, ...body } = params;
+        const headers = await this.getAuthHeaders(sessionToken);
+        return this.request("/ai/generate-image", {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+        });
+    }
+}
+/**
+ * Factory pour créer un client LastBrain
+ */
+export function createLBClient(config) {
+    return new LBClient(config);
+}

package/dist/index.d.ts

@@ -1,8 +1,11 @@
 export * from "./types";
+export * from "./types/auth";
 export * from "./errors/errorCodes";
 export * from "./errors/normalizeError";
 export * from "./client/createClient";
+export * from "./client/lb-client";
 export * from "./route-handlers/nextjs/gateway";
 export { GET as EnhancedGET, POST as EnhancedPOST, PUT as EnhancedPUT, } from "./route-handlers/nextjs/enhanced-gateway";
 export * as enhancedGateway from "./route-handlers/nextjs/enhanced-gateway";
+export * from "./route-handlers/nextjs/lb-proxy";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AAGtC,cAAc,iCAAiC,CAAC;AAChD,OAAO,EACL,GAAG,IAAI,WAAW,EAClB,IAAI,IAAI,YAAY,EACpB,GAAG,IAAI,WAAW,GACnB,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,eAAe,MAAM,0CAA0C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,iCAAiC,CAAC;AAChD,OAAO,EACL,GAAG,IAAI,WAAW,EAClB,IAAI,IAAI,YAAY,EACpB,GAAG,IAAI,WAAW,GACnB,MAAM,0CAA0C,CAAC;AAClD,OAAO,KAAK,eAAe,MAAM,0CAA0C,CAAC;AAC5E,cAAc,kCAAkC,CAAC"}

package/dist/index.js

@@ -1,8 +1,11 @@
 export * from "./types";
+export * from "./types/auth";
 export * from "./errors/errorCodes";
 export * from "./errors/normalizeError";
 export * from "./client/createClient";
+export * from "./client/lb-client";
 // Route handlers
 export * from "./route-handlers/nextjs/gateway";
 export { GET as EnhancedGET, POST as EnhancedPOST, PUT as EnhancedPUT, } from "./route-handlers/nextjs/enhanced-gateway";
 export * as enhancedGateway from "./route-handlers/nextjs/enhanced-gateway";
+export * from "./route-handlers/nextjs/lb-proxy";

package/dist/route-handlers/nextjs/lb-proxy.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Proxy handler pour Next.js App Router
+ * Permet de faire des appels IA LastBrain depuis le serveur
+ * avec support de LB_API_KEY ou session cookie
+ */
+import { NextRequest, NextResponse } from "next/server";
+/**
+ * Configuration du proxy LastBrain
+ */
+export interface LBProxyConfig {
+    /** URL de base de l'API LastBrain */
+    baseUrl?: string;
+    /** Clé API LastBrain (optionnel, peut utiliser env) */
+    apiKey?: string;
+    /** Nom du cookie de session */
+    sessionCookieName?: string;
+}
+/**
+ * Crée un handler de proxy unifié pour Next.js App Router
+ *
+ * Usage:
+ * ```typescript
+ * // app/api/lastbrain/[...path]/route.ts
+ * import { createLBProxyHandler } from "@lastbrain/ai-ui-core";
+ *
+ * export const { GET, POST, PUT, DELETE, PATCH } = createLBProxyHandler({
+ *   baseUrl: process.env.LB_BASE_URL,
+ * });
+ * ```
+ */
+export declare function createLBProxyHandler(config?: LBProxyConfig): {
+    GET: (request: NextRequest, context?: {
+        params: Promise<{
+            path?: string[];
+        }>;
+    }) => Promise<NextResponse>;
+    POST: (request: NextRequest, context?: {
+        params: Promise<{
+            path?: string[];
+        }>;
+    }) => Promise<NextResponse>;
+    PUT: (request: NextRequest, context?: {
+        params: Promise<{
+            path?: string[];
+        }>;
+    }) => Promise<NextResponse>;
+    DELETE: (request: NextRequest, context?: {
+        params: Promise<{
+            path?: string[];
+        }>;
+    }) => Promise<NextResponse>;
+    PATCH: (request: NextRequest, context?: {
+        params: Promise<{
+            path?: string[];
+        }>;
+    }) => Promise<NextResponse>;
+};
+/**
+ * Helper pour ajouter ou mettre à jour le cookie de session
+ */
+export declare function setLBSessionCookie(response: NextResponse, sessionToken: string, expiresIn?: number): NextResponse;
+/**
+ * Helper pour supprimer le cookie de session
+ */
+export declare function clearLBSessionCookie(response: NextResponse): NextResponse;
+//# sourceMappingURL=lb-proxy.d.ts.map

package/dist/route-handlers/nextjs/lb-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lb-proxy.d.ts","sourceRoot":"","sources":["../../../src/route-handlers/nextjs/lb-proxy.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,qCAAqC;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uDAAuD;IACvD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+BAA+B;IAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,GAAE,aAAkB;mBAWlD,WAAW,YACV;QAAE,MAAM,EAAE,OAAO,CAAC;YAAE,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;SAAE,CAAC,CAAA;KAAE,KACjD,OAAO,CAAC,YAAY,CAAC;oBAFb,WAAW,YACV;QAAE,MAAM,EAAE,OAAO,CAAC;YAAE,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;SAAE,CAAC,CAAA;KAAE,KACjD,OAAO,CAAC,YAAY,CAAC;mBAFb,WAAW,YACV;QAAE,MAAM,EAAE,OAAO,CAAC;YAAE,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;SAAE,CAAC,CAAA;KAAE,KACjD,OAAO,CAAC,YAAY,CAAC;sBAFb,WAAW,YACV;QAAE,MAAM,EAAE,OAAO,CAAC;YAAE,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;SAAE,CAAC,CAAA;KAAE,KACjD,OAAO,CAAC,YAAY,CAAC;qBAFb,WAAW,YACV;QAAE,MAAM,EAAE,OAAO,CAAC;YAAE,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;SAAE,CAAC,CAAA;KAAE,KACjD,OAAO,CAAC,YAAY,CAAC;EAiHzB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,YAAY,EACtB,YAAY,EAAE,MAAM,EACpB,SAAS,GAAE,MAAe,GACzB,YAAY,CAYd;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,YAAY,GAAG,YAAY,CAGzE"}

package/dist/route-handlers/nextjs/lb-proxy.js

@@ -0,0 +1,147 @@
+/**
+ * Proxy handler pour Next.js App Router
+ * Permet de faire des appels IA LastBrain depuis le serveur
+ * avec support de LB_API_KEY ou session cookie
+ */
+import { NextResponse } from "next/server";
+/**
+ * Crée un handler de proxy unifié pour Next.js App Router
+ *
+ * Usage:
+ * ```typescript
+ * // app/api/lastbrain/[...path]/route.ts
+ * import { createLBProxyHandler } from "@lastbrain/ai-ui-core";
+ *
+ * export const { GET, POST, PUT, DELETE, PATCH } = createLBProxyHandler({
+ *   baseUrl: process.env.LB_BASE_URL,
+ * });
+ * ```
+ */
+export function createLBProxyHandler(config = {}) {
+    const { baseUrl = process.env.LB_BASE_URL || "https://lastbrain.io", apiKey = process.env.LB_API_KEY, sessionCookieName = "lb_session", } = config;
+    /**
+     * Handler unique pour toutes les méthodes HTTP et tous les paths
+     */
+    async function handler(request, context) {
+        try {
+            // Extraire le path depuis l'URL ou les params
+            let path = "";
+            if (context?.params) {
+                const resolvedParams = await context.params;
+                path = resolvedParams.path?.join("/") || "";
+            }
+            else {
+                // Fallback: extraire depuis l'URL
+                const url = new URL(request.url);
+                const pathMatch = url.pathname.match(/\/api\/lastbrain\/(.*)/);
+                path = pathMatch ? pathMatch[1] : "";
+            }
+            // Routes publiques qui ne nécessitent pas d'authentification
+            const publicPaths = [
+                "auth/login",
+                "auth/session/create",
+                "public/user/api-keys",
+            ];
+            const isPublicPath = publicPaths.some((p) => path.startsWith(p));
+            // Construire l'URL complète vers LastBrain
+            const targetUrl = `${baseUrl}/api/ai/${path}`;
+            // Préparer les headers
+            const headers = {};
+            // Copier les headers pertinents de la requête originale
+            const contentType = request.headers.get("content-type");
+            if (contentType) {
+                headers["Content-Type"] = contentType;
+            }
+            const authorization = request.headers.get("authorization");
+            if (authorization) {
+                headers["Authorization"] = authorization;
+            }
+            // Authentification : LB_API_KEY ou session cookie
+            if (!authorization) {
+                if (apiKey) {
+                    headers["Authorization"] = `Bearer ${apiKey}`;
+                }
+                else {
+                    // Lire le cookie de session
+                    const sessionToken = request.cookies.get(sessionCookieName)?.value;
+                    if (sessionToken) {
+                        headers["Authorization"] = `Bearer ${sessionToken}`;
+                    }
+                    else if (!isPublicPath) {
+                        // Pas d'auth disponible et route protégée
+                        return NextResponse.json({
+                            error: "No authentication provided",
+                            hint: "Set LB_API_KEY env variable or login via /api/lastbrain/auth/login",
+                        }, { status: 401 });
+                    }
+                }
+            }
+            // Lire le body si c'est POST/PUT/PATCH
+            let body = undefined;
+            if (["POST", "PUT", "PATCH"].includes(request.method)) {
+                const text = await request.text();
+                if (text) {
+                    body = text;
+                }
+            }
+            // Faire la requête au backend LastBrain
+            const response = await fetch(targetUrl, {
+                method: request.method,
+                headers,
+                body,
+            });
+            // Lire la réponse
+            const responseText = await response.text();
+            let data;
+            try {
+                data = responseText ? JSON.parse(responseText) : {};
+            }
+            catch {
+                data = { error: "Invalid JSON response", raw: responseText };
+            }
+            // Créer la réponse Next.js
+            const nextResponse = NextResponse.json(data, { status: response.status });
+            // Copier les cookies de la réponse (notamment lb_session)
+            const setCookie = response.headers.get("set-cookie");
+            if (setCookie) {
+                nextResponse.headers.set("set-cookie", setCookie);
+            }
+            return nextResponse;
+        }
+        catch (error) {
+            console.error("[LB Proxy] Error:", error);
+            return NextResponse.json({ error: error instanceof Error ? error.message : "Proxy error" }, { status: 500 });
+        }
+    }
+    // Retourner un objet avec les handlers pour chaque méthode HTTP
+    return {
+        GET: handler,
+        POST: handler,
+        PUT: handler,
+        DELETE: handler,
+        PATCH: handler,
+    };
+}
+/**
+ * Helper pour ajouter ou mettre à jour le cookie de session
+ */
+export function setLBSessionCookie(response, sessionToken, expiresIn = 259200 // 72h en secondes
+) {
+    response.cookies.set({
+        name: "lb_session",
+        value: sessionToken,
+        httpOnly: true,
+        secure: process.env.NODE_ENV === "production",
+        sameSite: "lax",
+        path: "/",
+        maxAge: expiresIn,
+    });
+    return response;
+}
+/**
+ * Helper pour supprimer le cookie de session
+ */
+export function clearLBSessionCookie(response) {
+    response.cookies.delete("lb_session");
+    return response;
+}

package/dist/types/auth.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Types pour le système d'authentification LastBrain
+ * Permet l'utilisation des services IA avec LB_API_KEY ou session utilisateur
+ */
+/**
+ * Configuration du client LastBrain
+ */
+export interface LBAuthConfig {
+    /** URL de base de l'API LastBrain (ex: https://api.lastbrain.io) */
+    baseUrl?: string;
+    /** Clé API LastBrain (côté serveur uniquement) */
+    apiKey?: string;
+    /** Mode d'authentification */
+    mode?: "env-key" | "session" | "auto";
+}
+/**
+ * Session utilisateur LastBrain (stockée dans cookie HttpOnly)
+ */
+export interface LBSession {
+    /** Token de session opaque signé côté serveur */
+    sessionToken: string;
+    /** ID utilisateur associé */
+    userId: string;
+    /** ID de la clé API sélectionnée */
+    apiKeyId: string;
+    /** Timestamp d'expiration (72h après création) */
+    expiresAt: number;
+    /** Scopes/permissions accordés */
+    scopes?: string[];
+    /** Quotas restants (optionnel) */
+    quotas?: {
+        tokens?: number;
+        requests?: number;
+    };
+}
+/**
+ * Informations utilisateur LastBrain
+ */
+export interface LBUser {
+    id: string;
+    email: string;
+    name?: string;
+    avatar?: string;
+}
+/**
+ * Clé API LastBrain de l'utilisateur
+ */
+export interface LBApiKey {
+    id: string;
+    name: string;
+    /** Préfixe visible de la clé (ex: "lb_live_abc...") */
+    keyPrefix: string;
+    scopes: string[];
+    isActive: boolean;
+    createdAt: string;
+    lastUsedAt?: string;
+}
+/**
+ * Résultat de connexion
+ */
+export interface LBLoginResult {
+    /** Token d'accès temporaire pour récupérer les clés API */
+    accessToken: string;
+    /** Informations utilisateur */
+    user: LBUser;
+}
+/**
+ * Résultat de création de session
+ */
+export interface LBSessionResult {
+    /** Token de session opaque (72h) */
+    sessionToken: string;
+    /** Durée de validité en secondes (259200 = 72h) */
+    expiresIn: number;
+    /** Clé API sélectionnée */
+    apiKey: LBApiKey;
+}
+/**
+ * Statut d'authentification
+ */
+export type LBAuthStatus = "ready" | "needs_auth" | "loading" | "error";
+/**
+ * État d'authentification complet
+ */
+export interface LBAuthState {
+    /** Statut actuel */
+    status: LBAuthStatus;
+    /** Utilisateur connecté (si session active) */
+    user?: LBUser;
+    /** Clé API sélectionnée (si session active) */
+    selectedKey?: LBApiKey;
+    /** Session active */
+    session?: LBSession;
+    /** Erreur éventuelle */
+    error?: string;
+}
+/**
+ * Options pour les requêtes IA
+ */
+export interface LBRequestOptions {
+    /** URL de base (override config) */
+    baseUrl?: string;
+    /** Headers supplémentaires */
+    headers?: Record<string, string>;
+    /** Timeout en ms */
+    timeout?: number;
+}
+//# sourceMappingURL=auth.d.ts.map

package/dist/types/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/types/auth.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,kDAAkD;IAClD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8BAA8B;IAC9B,IAAI,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,iDAAiD;IACjD,YAAY,EAAE,MAAM,CAAC;IACrB,6BAA6B;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,oCAAoC;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,kDAAkD;IAClD,SAAS,EAAE,MAAM,CAAC;IAClB,kCAAkC;IAClC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,kCAAkC;IAClC,MAAM,CAAC,EAAE;QACP,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,MAAM;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,2DAA2D;IAC3D,WAAW,EAAE,MAAM,CAAC;IACpB,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,oCAAoC;IACpC,YAAY,EAAE,MAAM,CAAC;IACrB,mDAAmD;IACnD,SAAS,EAAE,MAAM,CAAC;IAClB,2BAA2B;IAC3B,MAAM,EAAE,QAAQ,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,YAAY,GAAG,SAAS,GAAG,OAAO,CAAC;AAExE;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,oBAAoB;IACpB,MAAM,EAAE,YAAY,CAAC;IACrB,+CAA+C;IAC/C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,+CAA+C;IAC/C,WAAW,CAAC,EAAE,QAAQ,CAAC;IACvB,qBAAqB;IACrB,OAAO,CAAC,EAAE,SAAS,CAAC;IACpB,wBAAwB;IACxB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,oCAAoC;IACpC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,8BAA8B;IAC9B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,oBAAoB;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB"}

package/dist/types/auth.js

@@ -0,0 +1,5 @@
+/**
+ * Types pour le système d'authentification LastBrain
+ * Permet l'utilisation des services IA avec LB_API_KEY ou session utilisateur
+ */
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lastbrain/ai-ui-core",
-  "version": "1.0.28",
+  "version": "1.0.30",
   "description": "Framework-agnostic core library for LastBrain AI UI Kit",
   "private": false,
   "type": "module",

package/src/client/lb-client.ts

@@ -0,0 +1,220 @@
+/**
+ * Client LastBrain intelligent
+ * Supporte deux modes d'authentification :
+ * - env-key : utilise LB_API_KEY (côté serveur)
+ * - session : utilise cookie lb_session (user authentifié)
+ */
+
+import type {
+  LBAuthConfig,
+  LBSession,
+  LBRequestOptions,
+  LBLoginResult,
+  LBApiKey,
+  LBSessionResult,
+} from "../types/auth";
+
+export class LBClient {
+  private config: Required<LBAuthConfig>;
+
+  constructor(config: LBAuthConfig = {}) {
+    this.config = {
+      baseUrl:
+        config.baseUrl ||
+        process.env.LB_BASE_URL ||
+        "https://prompt.lastbrain.io",
+      apiKey: config.apiKey || process.env.LB_API_KEY || "",
+      mode: config.mode || "auto",
+    };
+  }
+
+  /**
+   * Détecte le mode d'authentification à utiliser
+   */
+  private getAuthMode(): "env-key" | "session" {
+    if (this.config.mode === "env-key") return "env-key";
+    if (this.config.mode === "session") return "session";
+
+    // Mode auto : préfère env-key si disponible
+    return this.config.apiKey ? "env-key" : "session";
+  }
+
+  /**
+   * Construit les headers d'authentification
+   */
+  private async getAuthHeaders(
+    sessionToken?: string
+  ): Promise<Record<string, string>> {
+    const mode = this.getAuthMode();
+
+    if (mode === "env-key" && this.config.apiKey) {
+      return {
+        Authorization: `Bearer ${this.config.apiKey}`,
+      };
+    }
+
+    // Mode session : utilise le token fourni ou tente de lire le cookie
+    if (sessionToken) {
+      return {
+        Authorization: `Bearer ${sessionToken}`,
+      };
+    }
+
+    // Si aucun token fourni, la requête échouera (attendu pour déclencher auth)
+    return {};
+  }
+
+  /**
+   * Fait une requête à l'API LastBrain
+   */
+  private async request<T>(
+    endpoint: string,
+    options: RequestInit & LBRequestOptions = {}
+  ): Promise<T> {
+    const {
+      baseUrl,
+      headers: customHeaders,
+      timeout,
+      ...fetchOptions
+    } = options;
+
+    const url = `${baseUrl || this.config.baseUrl}${endpoint}`;
+    const authHeaders = await this.getAuthHeaders();
+
+    const controller = new AbortController();
+    const timeoutId = timeout
+      ? setTimeout(() => controller.abort(), timeout)
+      : undefined;
+
+    try {
+      const response = await fetch(url, {
+        ...fetchOptions,
+        headers: {
+          "Content-Type": "application/json",
+          ...authHeaders,
+          ...customHeaders,
+        },
+        signal: controller.signal,
+      });
+
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        throw new Error(error.message || `HTTP ${response.status}`);
+      }
+
+      return await response.json();
+    } finally {
+      if (timeoutId) clearTimeout(timeoutId);
+    }
+  }
+
+  /**
+   * Login utilisateur (email + password)
+   * Retourne un access_token temporaire pour récupérer les clés API
+   */
+  async login(email: string, password: string): Promise<LBLoginResult> {
+    return this.request<LBLoginResult>("/auth/login", {
+      method: "POST",
+      body: JSON.stringify({ email, password }),
+    });
+  }
+
+  /**
+   * Récupère les clés API de l'utilisateur
+   */
+  async getUserApiKeys(accessToken: string): Promise<LBApiKey[]> {
+    return this.request<LBApiKey[]>("/user/api-keys", {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+    });
+  }
+
+  /**
+   * Crée une session (72h) avec une clé API sélectionnée
+   */
+  async createSession(
+    accessToken: string,
+    apiKeyId: string
+  ): Promise<LBSessionResult> {
+    return this.request<LBSessionResult>("/auth/session", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+      },
+      body: JSON.stringify({ api_key_id: apiKeyId }),
+    });
+  }
+
+  /**
+   * Vérifie si une session est valide
+   */
+  async verifySession(sessionToken: string): Promise<LBSession | null> {
+    try {
+      return await this.request<LBSession>("/auth/session/verify", {
+        headers: {
+          Authorization: `Bearer ${sessionToken}`,
+        },
+      });
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Déconnexion (invalide la session)
+   */
+  async logout(sessionToken: string): Promise<void> {
+    await this.request("/auth/session/logout", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${sessionToken}`,
+      },
+    });
+  }
+
+  /**
+   * Fait un appel IA (génération de texte)
+   */
+  async generateText(params: {
+    prompt: string;
+    model?: string;
+    sessionToken?: string;
+    [key: string]: any;
+  }): Promise<any> {
+    const { sessionToken, ...body } = params;
+    const headers = await this.getAuthHeaders(sessionToken);
+
+    return this.request("/ai/generate-text", {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+    });
+  }
+
+  /**
+   * Fait un appel IA (génération d'image)
+   */
+  async generateImage(params: {
+    prompt: string;
+    model?: string;
+    sessionToken?: string;
+    [key: string]: any;
+  }): Promise<any> {
+    const { sessionToken, ...body } = params;
+    const headers = await this.getAuthHeaders(sessionToken);
+
+    return this.request("/ai/generate-image", {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+    });
+  }
+}
+
+/**
+ * Factory pour créer un client LastBrain
+ */
+export function createLBClient(config?: LBAuthConfig): LBClient {
+  return new LBClient(config);
+}

package/src/index.ts

@@ -1,7 +1,9 @@
 export * from "./types";
+export * from "./types/auth";
 export * from "./errors/errorCodes";
 export * from "./errors/normalizeError";
 export * from "./client/createClient";
+export * from "./client/lb-client";
 
 // Route handlers
 export * from "./route-handlers/nextjs/gateway";
@@ -11,3 +13,4 @@ export {
   PUT as EnhancedPUT,
 } from "./route-handlers/nextjs/enhanced-gateway";
 export * as enhancedGateway from "./route-handlers/nextjs/enhanced-gateway";
+export * from "./route-handlers/nextjs/lb-proxy";

package/src/route-handlers/nextjs/lb-proxy.ts

@@ -0,0 +1,189 @@
+/**
+ * Proxy handler pour Next.js App Router
+ * Permet de faire des appels IA LastBrain depuis le serveur
+ * avec support de LB_API_KEY ou session cookie
+ */
+
+import { NextRequest, NextResponse } from "next/server";
+
+/**
+ * Configuration du proxy LastBrain
+ */
+export interface LBProxyConfig {
+  /** URL de base de l'API LastBrain */
+  baseUrl?: string;
+  /** Clé API LastBrain (optionnel, peut utiliser env) */
+  apiKey?: string;
+  /** Nom du cookie de session */
+  sessionCookieName?: string;
+}
+
+/**
+ * Crée un handler de proxy unifié pour Next.js App Router
+ *
+ * Usage:
+ * ```typescript
+ * // app/api/lastbrain/[...path]/route.ts
+ * import { createLBProxyHandler } from "@lastbrain/ai-ui-core";
+ *
+ * export const { GET, POST, PUT, DELETE, PATCH } = createLBProxyHandler({
+ *   baseUrl: process.env.LB_BASE_URL,
+ * });
+ * ```
+ */
+export function createLBProxyHandler(config: LBProxyConfig = {}) {
+  const {
+    baseUrl = process.env.LB_BASE_URL || "https://lastbrain.io",
+    apiKey = process.env.LB_API_KEY,
+    sessionCookieName = "lb_session",
+  } = config;
+
+  /**
+   * Handler unique pour toutes les méthodes HTTP et tous les paths
+   */
+  async function handler(
+    request: NextRequest,
+    context?: { params: Promise<{ path?: string[] }> }
+  ): Promise<NextResponse> {
+    try {
+      // Extraire le path depuis l'URL ou les params
+      let path = "";
+      if (context?.params) {
+        const resolvedParams = await context.params;
+        path = resolvedParams.path?.join("/") || "";
+      } else {
+        // Fallback: extraire depuis l'URL
+        const url = new URL(request.url);
+        const pathMatch = url.pathname.match(/\/api\/lastbrain\/(.*)/);
+        path = pathMatch ? pathMatch[1] : "";
+      }
+
+      // Routes publiques qui ne nécessitent pas d'authentification
+      const publicPaths = [
+        "auth/login",
+        "auth/session/create",
+        "public/user/api-keys",
+      ];
+      const isPublicPath = publicPaths.some((p) => path.startsWith(p));
+
+      // Construire l'URL complète vers LastBrain
+      const targetUrl = `${baseUrl}/api/ai/${path}`;
+
+      // Préparer les headers
+      const headers: Record<string, string> = {};
+
+      // Copier les headers pertinents de la requête originale
+      const contentType = request.headers.get("content-type");
+      if (contentType) {
+        headers["Content-Type"] = contentType;
+      }
+
+      const authorization = request.headers.get("authorization");
+      if (authorization) {
+        headers["Authorization"] = authorization;
+      }
+
+      // Authentification : LB_API_KEY ou session cookie
+      if (!authorization) {
+        if (apiKey) {
+          headers["Authorization"] = `Bearer ${apiKey}`;
+        } else {
+          // Lire le cookie de session
+          const sessionToken = request.cookies.get(sessionCookieName)?.value;
+          if (sessionToken) {
+            headers["Authorization"] = `Bearer ${sessionToken}`;
+          } else if (!isPublicPath) {
+            // Pas d'auth disponible et route protégée
+            return NextResponse.json(
+              {
+                error: "No authentication provided",
+                hint: "Set LB_API_KEY env variable or login via /api/lastbrain/auth/login",
+              },
+              { status: 401 }
+            );
+          }
+        }
+      }
+
+      // Lire le body si c'est POST/PUT/PATCH
+      let body: string | undefined = undefined;
+      if (["POST", "PUT", "PATCH"].includes(request.method)) {
+        const text = await request.text();
+        if (text) {
+          body = text;
+        }
+      }
+
+      // Faire la requête au backend LastBrain
+      const response = await fetch(targetUrl, {
+        method: request.method,
+        headers,
+        body,
+      });
+
+      // Lire la réponse
+      const responseText = await response.text();
+      let data: any;
+      try {
+        data = responseText ? JSON.parse(responseText) : {};
+      } catch {
+        data = { error: "Invalid JSON response", raw: responseText };
+      }
+
+      // Créer la réponse Next.js
+      const nextResponse = NextResponse.json(data, { status: response.status });
+
+      // Copier les cookies de la réponse (notamment lb_session)
+      const setCookie = response.headers.get("set-cookie");
+      if (setCookie) {
+        nextResponse.headers.set("set-cookie", setCookie);
+      }
+
+      return nextResponse;
+    } catch (error) {
+      console.error("[LB Proxy] Error:", error);
+      return NextResponse.json(
+        { error: error instanceof Error ? error.message : "Proxy error" },
+        { status: 500 }
+      );
+    }
+  }
+
+  // Retourner un objet avec les handlers pour chaque méthode HTTP
+  return {
+    GET: handler,
+    POST: handler,
+    PUT: handler,
+    DELETE: handler,
+    PATCH: handler,
+  };
+}
+
+/**
+ * Helper pour ajouter ou mettre à jour le cookie de session
+ */
+export function setLBSessionCookie(
+  response: NextResponse,
+  sessionToken: string,
+  expiresIn: number = 259200 // 72h en secondes
+): NextResponse {
+  response.cookies.set({
+    name: "lb_session",
+    value: sessionToken,
+    httpOnly: true,
+    secure: process.env.NODE_ENV === "production",
+    sameSite: "lax",
+    path: "/",
+    maxAge: expiresIn,
+  });
+
+  return response;
+}
+
+/**
+ * Helper pour supprimer le cookie de session
+ */
+export function clearLBSessionCookie(response: NextResponse): NextResponse {
+  response.cookies.delete("lb_session");
+  return response;
+}

package/src/types/auth.ts

@@ -0,0 +1,116 @@
+/**
+ * Types pour le système d'authentification LastBrain
+ * Permet l'utilisation des services IA avec LB_API_KEY ou session utilisateur
+ */
+
+/**
+ * Configuration du client LastBrain
+ */
+export interface LBAuthConfig {
+  /** URL de base de l'API LastBrain (ex: https://api.lastbrain.io) */
+  baseUrl?: string;
+  /** Clé API LastBrain (côté serveur uniquement) */
+  apiKey?: string;
+  /** Mode d'authentification */
+  mode?: "env-key" | "session" | "auto";
+}
+
+/**
+ * Session utilisateur LastBrain (stockée dans cookie HttpOnly)
+ */
+export interface LBSession {
+  /** Token de session opaque signé côté serveur */
+  sessionToken: string;
+  /** ID utilisateur associé */
+  userId: string;
+  /** ID de la clé API sélectionnée */
+  apiKeyId: string;
+  /** Timestamp d'expiration (72h après création) */
+  expiresAt: number;
+  /** Scopes/permissions accordés */
+  scopes?: string[];
+  /** Quotas restants (optionnel) */
+  quotas?: {
+    tokens?: number;
+    requests?: number;
+  };
+}
+
+/**
+ * Informations utilisateur LastBrain
+ */
+export interface LBUser {
+  id: string;
+  email: string;
+  name?: string;
+  avatar?: string;
+}
+
+/**
+ * Clé API LastBrain de l'utilisateur
+ */
+export interface LBApiKey {
+  id: string;
+  name: string;
+  /** Préfixe visible de la clé (ex: "lb_live_abc...") */
+  keyPrefix: string;
+  scopes: string[];
+  isActive: boolean;
+  createdAt: string;
+  lastUsedAt?: string;
+}
+
+/**
+ * Résultat de connexion
+ */
+export interface LBLoginResult {
+  /** Token d'accès temporaire pour récupérer les clés API */
+  accessToken: string;
+  /** Informations utilisateur */
+  user: LBUser;
+}
+
+/**
+ * Résultat de création de session
+ */
+export interface LBSessionResult {
+  /** Token de session opaque (72h) */
+  sessionToken: string;
+  /** Durée de validité en secondes (259200 = 72h) */
+  expiresIn: number;
+  /** Clé API sélectionnée */
+  apiKey: LBApiKey;
+}
+
+/**
+ * Statut d'authentification
+ */
+export type LBAuthStatus = "ready" | "needs_auth" | "loading" | "error";
+
+/**
+ * État d'authentification complet
+ */
+export interface LBAuthState {
+  /** Statut actuel */
+  status: LBAuthStatus;
+  /** Utilisateur connecté (si session active) */
+  user?: LBUser;
+  /** Clé API sélectionnée (si session active) */
+  selectedKey?: LBApiKey;
+  /** Session active */
+  session?: LBSession;
+  /** Erreur éventuelle */
+  error?: string;
+}
+
+/**
+ * Options pour les requêtes IA
+ */
+export interface LBRequestOptions {
+  /** URL de base (override config) */
+  baseUrl?: string;
+  /** Headers supplémentaires */
+  headers?: Record<string, string>;
+  /** Timeout en ms */
+  timeout?: number;
+}