@lastbrain/module-ai 2.0.26 → 2.0.30

package/dist/api/public/v1/prompts.js

@@ -0,0 +1,107 @@
+/**
+ * GET /api/public/v1/prompts
+ * Get user's prompts via Bearer token authentication
+ */
+import { NextResponse } from "next/server";
+import { randomUUID } from "crypto";
+import { logger } from "@lastbrain/core";
+import { getSupabaseServiceClient } from "@lastbrain/core/server";
+import { validateApiKey } from "./_lib/auth";
+import { createErrorResponse } from "./_lib/errors";
+import { logApiCall, updateApiKeyLastUsed } from "./_lib/log";
+export async function GET(request) {
+    const startTime = Date.now();
+    const requestId = randomUUID();
+    let apiKeyId = null;
+    let ownerId = null;
+    let statusCode = 200;
+    let errorCode = null;
+    try {
+        const authHeader = request.headers.get("Authorization");
+        // 1. Validate API key
+        const authResult = await validateApiKey(authHeader);
+        if (!authResult.success || !authResult.apiKey) {
+            const { response, status } = createErrorResponse(authResult.errorCode, authResult.error || "Authentication failed", requestId, undefined, 401);
+            statusCode = status;
+            errorCode = authResult.errorCode || null;
+            return NextResponse.json(response, { status });
+        }
+        const apiKey = authResult.apiKey;
+        apiKeyId = apiKey.id;
+        ownerId = apiKey.owner_id;
+        // 2. Get query parameters
+        const { searchParams } = new URL(request.url);
+        const type = searchParams.get("type"); // 'text' or 'image'
+        const favorite = searchParams.get("favorite") === "true";
+        const publicOnly = searchParams.get("public") === "true";
+        // 3. Get prompts
+        const supabase = await getSupabaseServiceClient();
+        let query = supabase
+            .from("user_prompt")
+            .select("id, title, content, type, tags, is_public, favorite, created_at")
+            .eq("owner_id", ownerId)
+            .order("favorite", { ascending: false })
+            .order("created_at", { ascending: false });
+        if (type) {
+            query = query.eq("type", type);
+        }
+        if (favorite) {
+            query = query.eq("favorite", true);
+        }
+        if (publicOnly) {
+            query = query.eq("is_public", true);
+        }
+        const { data: prompts, error } = await query;
+        if (error) {
+            logger.error("[prompts] Error fetching prompts:", error);
+            statusCode = 500;
+            errorCode = "DATABASE_ERROR";
+            const { response, status } = createErrorResponse("INTERNAL_ERROR", "Failed to fetch prompts", requestId, undefined, 500);
+            return NextResponse.json(response, { status });
+        }
+        // 4. Update API key last used
+        await updateApiKeyLastUsed(apiKey);
+        // 5. Log API call
+        await logApiCall({
+            apiKeyId,
+            ownerId,
+            endpoint: "prompts",
+            provider: null,
+            model: null,
+            tokensIn: null,
+            tokensOut: null,
+            tokensTotal: null,
+            latencyMs: Date.now() - startTime,
+            statusCode,
+            errorCode,
+            requestId,
+        });
+        return NextResponse.json({
+            request_id: requestId,
+            prompts,
+        });
+    }
+    catch (error) {
+        logger.error("[prompts] Unexpected error:", error);
+        statusCode = 500;
+        errorCode = "INTERNAL_ERROR";
+        if (apiKeyId && ownerId) {
+            await logApiCall({
+                apiKeyId,
+                ownerId,
+                endpoint: "prompts",
+                provider: null,
+                model: null,
+                tokensIn: null,
+                tokensOut: null,
+                tokensTotal: null,
+                latencyMs: Date.now() - startTime,
+                statusCode,
+                errorCode,
+                requestId,
+            });
+        }
+        const { response, status } = createErrorResponse("INTERNAL_ERROR", error.message || "Internal server error", requestId, undefined, 500);
+        return NextResponse.json(response, { status });
+    }
+}

package/dist/api/public/v1/provider.d.ts

@@ -0,0 +1,16 @@
+/**
+ * GET /api/public/v1/provider
+ * List available AI providers and models from Vercel AI Gateway
+ */
+import { NextRequest, NextResponse } from "next/server";
+export declare function GET(request: NextRequest): Promise<NextResponse<import("./_lib/errors").ApiError> | NextResponse<{
+    request_id: `${string}-${string}-${string}-${string}-${string}`;
+    providers: import("../../../types/gateway").GatewayProvider[];
+    stale: boolean | undefined;
+    cached_at: string | undefined;
+    user_settings: {
+        enabled_models: any;
+        enabled_providers: null;
+    };
+}>>;
+//# sourceMappingURL=provider.d.ts.map

package/dist/api/public/v1/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../../src/api/public/v1/provider.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AASxD,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;;;;;;IAwJ7C"}

package/dist/api/public/v1/provider.js

@@ -0,0 +1,130 @@
+/**
+ * GET /api/public/v1/provider
+ * List available AI providers and models from Vercel AI Gateway
+ */
+import { NextResponse } from "next/server";
+import { randomUUID } from "crypto";
+import { logger } from "@lastbrain/core";
+import { validateApiKey } from "./_lib/auth";
+import { createErrorResponse } from "./_lib/errors";
+import { logApiCall, updateApiKeyLastUsed } from "./_lib/log";
+import { fetchGatewayModels } from "../../../server/gateway-service";
+import { getSupabaseServiceClient } from "@lastbrain/core/server";
+export async function GET(request) {
+    const startTime = Date.now();
+    const requestId = randomUUID();
+    let apiKeyId = null;
+    let ownerId = null;
+    let statusCode = 200;
+    let errorCode = null;
+    try {
+        const authHeader = request.headers.get("Authorization");
+        console.log("🚀 ~ GET ~ authHeader:", authHeader);
+        // 1. Validate API key
+        const authResult = await validateApiKey(authHeader);
+        if (!authResult.success || !authResult.apiKey) {
+            const { response, status } = createErrorResponse(authResult.errorCode, authResult.error || "Authentication failed", requestId, undefined, 401);
+            statusCode = status;
+            errorCode = authResult.errorCode || null;
+            return NextResponse.json(response, { status });
+        }
+        const apiKey = authResult.apiKey;
+        apiKeyId = apiKey.id;
+        ownerId = apiKey.owner_id;
+        // 2. Get query parameters
+        const searchParams = request.nextUrl.searchParams;
+        const kindFilter = searchParams.get("kind"); // "text" or "image"
+        const includeDisabled = searchParams.get("include_disabled") === "true";
+        // 3. Fetch models from Vercel AI Gateway
+        const gatewayResponse = await fetchGatewayModels();
+        // 4. Get user's enabled models settings
+        const supabase = await getSupabaseServiceClient();
+        const { data: settings } = await supabase
+            .from("user_ai_settings")
+            .select("allowed_models")
+            .eq("owner_id", ownerId)
+            .single();
+        console.log("🚀 ~ GET ~ settings:", settings);
+        const enabledModels = settings?.allowed_models || [];
+        const enabledProviders = null; // No provider filter in user_ai_settings
+        // 5. Filter models based on user settings (unless include_disabled=true)
+        let filteredProviders = gatewayResponse.providers;
+        // Only filter if allowed_models is explicitly set and include_disabled is false
+        if (!includeDisabled && enabledModels.length > 0) {
+            filteredProviders = gatewayResponse.providers
+                .map((provider) => {
+                // Filter models by allowed_models
+                const filteredModels = provider.models.filter((model) => enabledModels.includes(model.id));
+                if (filteredModels.length === 0) {
+                    return null;
+                }
+                return {
+                    ...provider,
+                    models: filteredModels,
+                };
+            })
+                .filter((p) => p !== null);
+            console.log("🚀 ~ GET ~ filteredProviders count:", filteredProviders.length, "total models:", filteredProviders.reduce((sum, p) => sum + p.models.length, 0));
+        }
+        // 6. Apply kind filter if specified
+        if (kindFilter) {
+            filteredProviders = filteredProviders
+                .map((provider) => ({
+                ...provider,
+                models: provider.models.filter((m) => m.type === kindFilter),
+            }))
+                .filter((p) => p.models.length > 0);
+        }
+        // 7. Update API key last used
+        await updateApiKeyLastUsed(apiKey);
+        // 8. Log API call
+        await logApiCall({
+            apiKeyId,
+            ownerId,
+            endpoint: "provider",
+            provider: null,
+            model: null,
+            tokensIn: null,
+            tokensOut: null,
+            tokensTotal: null,
+            latencyMs: Date.now() - startTime,
+            statusCode,
+            errorCode,
+            requestId,
+        });
+        return NextResponse.json({
+            request_id: requestId,
+            providers: filteredProviders,
+            stale: gatewayResponse.stale,
+            cached_at: gatewayResponse.cached_at,
+            user_settings: {
+                enabled_models: enabledModels,
+                enabled_providers: enabledProviders,
+            },
+        });
+    }
+    catch (error) {
+        logger.error("[provider] Error:", error);
+        statusCode = 500;
+        errorCode = "INTERNAL_ERROR";
+        // Log failed API call
+        if (apiKeyId && ownerId) {
+            await logApiCall({
+                apiKeyId,
+                ownerId,
+                endpoint: "provider",
+                provider: null,
+                model: null,
+                tokensIn: null,
+                tokensOut: null,
+                tokensTotal: null,
+                latencyMs: Date.now() - startTime,
+                statusCode,
+                errorCode,
+                requestId,
+            });
+        }
+        const { response, status } = createErrorResponse("INTERNAL_ERROR", error.message, requestId);
+        return NextResponse.json(response, { status });
+    }
+}

package/dist/api/public/v1/purchase.d.ts

@@ -0,0 +1,11 @@
+/**
+ * GET /api/public/v1/purchase
+ * Get URL to purchase tokens
+ */
+import { NextRequest, NextResponse } from "next/server";
+export declare function GET(request: NextRequest): Promise<NextResponse<{
+    request_id: `${string}-${string}-${string}-${string}-${string}`;
+    purchase_url: string;
+    message: string;
+}>>;
+//# sourceMappingURL=purchase.d.ts.map

package/dist/api/public/v1/purchase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"purchase.d.ts","sourceRoot":"","sources":["../../../../src/api/public/v1/purchase.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAGxD,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;IAc7C"}

package/dist/api/public/v1/purchase.js

@@ -0,0 +1,18 @@
+/**
+ * GET /api/public/v1/purchase
+ * Get URL to purchase tokens
+ */
+import { NextResponse } from "next/server";
+import { randomUUID } from "crypto";
+export async function GET(request) {
+    const requestId = randomUUID();
+    // Get purchase URL from environment or use default
+    const purchaseUrl = process.env.TOKEN_PURCHASE_URL ||
+        process.env.NEXT_PUBLIC_APP_URL + "/auth/module-ai/tokens" ||
+        "/auth/module-ai/tokens";
+    return NextResponse.json({
+        request_id: requestId,
+        purchase_url: purchaseUrl,
+        message: "Visit this URL to purchase tokens for your account",
+    });
+}

package/dist/api/public/v1/status.d.ts

@@ -0,0 +1,35 @@
+/**
+ * GET /api/public/v1/status
+ * Get user status, balance, and quota information
+ */
+import { NextRequest, NextResponse } from "next/server";
+export declare function GET(request: NextRequest): Promise<NextResponse<import("./_lib/errors").ApiError> | NextResponse<{
+    request_id: `${string}-${string}-${string}-${string}-${string}`;
+    api_key: {
+        id: string;
+        name: string;
+        prefix: string;
+        env: string;
+        scopes: string[];
+        rate_limit_rpm: number;
+        daily_token_limit: bigint | null;
+        created_at: string;
+    };
+    balance: {
+        purchased: any;
+        quota: any;
+        total: any;
+    };
+    quota: any;
+    settings: {
+        mode: any;
+        max_tokens_per_call: any;
+    };
+    storage: {
+        db_mb: number;
+        files_mb: number;
+        total_mb: number;
+        allocated_mb: number;
+    };
+}>>;
+//# sourceMappingURL=status.d.ts.map

package/dist/api/public/v1/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../../../src/api/public/v1/status.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAQxD,wBAAsB,GAAG,CAAC,OAAO,EAAE,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA6L7C"}

package/dist/api/public/v1/status.js

@@ -0,0 +1,163 @@
+/**
+ * GET /api/public/v1/status
+ * Get user status, balance, and quota information
+ */
+import { NextResponse } from "next/server";
+import { randomUUID } from "crypto";
+import { logger, getStorageUsage } from "@lastbrain/core";
+import { getSupabaseServiceClient } from "@lastbrain/core/server";
+import { validateApiKey } from "./_lib/auth";
+import { createErrorResponse } from "./_lib/errors";
+import { logApiCall, updateApiKeyLastUsed } from "./_lib/log";
+export async function GET(request) {
+    const startTime = Date.now();
+    const requestId = randomUUID();
+    let apiKeyId = null;
+    let ownerId = null;
+    let statusCode = 200;
+    let errorCode = null;
+    try {
+        const authHeader = request.headers.get("Authorization");
+        // 1. Validate API key
+        const authResult = await validateApiKey(authHeader);
+        if (!authResult.success || !authResult.apiKey) {
+            const { response, status } = createErrorResponse(authResult.errorCode, authResult.error || "Authentication failed", requestId, undefined, 401);
+            statusCode = status;
+            errorCode = authResult.errorCode || null;
+            return NextResponse.json(response, { status });
+        }
+        const apiKey = authResult.apiKey;
+        apiKeyId = apiKey.id;
+        ownerId = apiKey.owner_id;
+        // 2. Get token balance (purchased)
+        const supabase = await getSupabaseServiceClient();
+        const { data: balanceData } = await supabase
+            .from("user_token_balance_v")
+            .select("balance")
+            .eq("owner_id", ownerId)
+            .single();
+        const purchasedBalance = balanceData?.balance || 0;
+        // 3. Get quota balance (monthly included)
+        const { data: quotaData } = await supabase
+            .from("user_token_quota_monthly")
+            .select("plan, effective_included_tokens, used_included_tokens, period_start, period_end")
+            .eq("owner_id", ownerId)
+            .single();
+        let quotaInfo = {
+            plan: "free",
+            effective_quota: 0,
+            used_quota: 0,
+            remaining_quota: 0,
+            period_start: null,
+            period_end: null,
+            is_active: false,
+        };
+        if (quotaData) {
+            const now = new Date();
+            const periodStart = quotaData.period_start
+                ? new Date(quotaData.period_start)
+                : null;
+            const periodEnd = quotaData.period_end
+                ? new Date(quotaData.period_end)
+                : null;
+            const isActive = periodStart && periodEnd && now >= periodStart && now <= periodEnd;
+            quotaInfo = {
+                plan: quotaData.plan,
+                effective_quota: quotaData.effective_included_tokens,
+                used_quota: quotaData.used_included_tokens || 0,
+                remaining_quota: isActive
+                    ? Math.max(0, quotaData.effective_included_tokens -
+                        (quotaData.used_included_tokens || 0))
+                    : 0,
+                period_start: quotaData.period_start,
+                period_end: quotaData.period_end,
+                is_active: isActive,
+            };
+        }
+        // 4. Get user AI settings
+        const { data: settings } = await supabase
+            .from("user_ai_settings")
+            .select("mode, max_tokens_per_call")
+            .eq("owner_id", ownerId)
+            .single();
+        const settingsInfo = {
+            mode: settings?.mode || "auto",
+            max_tokens_per_call: settings?.max_tokens_per_call || null,
+        };
+        // 5. Get storage info
+        const storageData = await getStorageUsage(supabase, ownerId);
+        const storageInfo = {
+            db_mb: 0, // getStorageUsage ne fait pas cette distinction
+            files_mb: storageData.usedBytes / (1024 * 1024),
+            total_mb: storageData.usedBytes / (1024 * 1024),
+            allocated_mb: storageData.allocatedBytes / (1024 * 1024),
+        };
+        // 6. API key info
+        const apiKeyInfo = {
+            id: apiKey.id,
+            name: apiKey.name,
+            prefix: apiKey.prefix,
+            env: apiKey.env,
+            scopes: apiKey.scopes,
+            rate_limit_rpm: apiKey.rate_limit_rpm,
+            daily_token_limit: apiKey.daily_token_limit,
+            created_at: apiKey.created_at,
+        };
+        // 7. Log API call
+        const latencyMs = Date.now() - startTime;
+        await logApiCall({
+            apiKeyId,
+            ownerId,
+            endpoint: "status",
+            provider: null,
+            model: null,
+            tokensIn: null,
+            tokensOut: null,
+            tokensTotal: null,
+            latencyMs,
+            statusCode,
+            errorCode: null,
+            requestId,
+        });
+        // 8. Update API key last used
+        await updateApiKeyLastUsed(apiKey);
+        // 9. Return response
+        return NextResponse.json({
+            request_id: requestId,
+            api_key: apiKeyInfo,
+            balance: {
+                purchased: purchasedBalance,
+                quota: quotaInfo.remaining_quota,
+                total: purchasedBalance + quotaInfo.remaining_quota,
+            },
+            quota: quotaInfo,
+            settings: settingsInfo,
+            storage: storageInfo,
+        });
+    }
+    catch (error) {
+        logger.error("[status] Unexpected error", error);
+        statusCode = 500;
+        errorCode = "INTERNAL_ERROR";
+        // Log error even in catch
+        if (apiKeyId && ownerId) {
+            const latencyMs = Date.now() - startTime;
+            await logApiCall({
+                apiKeyId,
+                ownerId,
+                endpoint: "status",
+                provider: null,
+                model: null,
+                tokensIn: null,
+                tokensOut: null,
+                tokensTotal: null,
+                latencyMs,
+                statusCode,
+                errorCode,
+                requestId,
+            });
+        }
+        const { response, status } = createErrorResponse("INTERNAL_ERROR", error.message || "Internal server error", requestId, undefined, 500);
+        return NextResponse.json(response, { status });
+    }
+}

package/dist/api/public/v1/text-ai.d.ts

@@ -0,0 +1,26 @@
+/**
+ * POST /api/public/v1/text-ai
+ * Generate text using AI
+ */
+import { NextRequest, NextResponse } from "next/server";
+export declare function POST(request: NextRequest): Promise<NextResponse<import("./_lib/errors").ApiError> | NextResponse<{
+    request_id: `${string}-${string}-${string}-${string}-${string}`;
+    text: string | undefined;
+    model: string | undefined;
+    provider: string | undefined;
+    tokens: {
+        input: number | undefined;
+        output: number | undefined;
+        total: number;
+    };
+    balance: {
+        remaining_quota: number;
+        remaining_purchased: any;
+        total: any;
+    };
+    artifact: {
+        id: string | undefined;
+        stored: boolean;
+    } | undefined;
+}>>;
+//# sourceMappingURL=text-ai.d.ts.map

package/dist/api/public/v1/text-ai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-ai.d.ts","sourceRoot":"","sources":["../../../../src/api/public/v1/text-ai.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAyBxD,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW;;;;;;;;;;;;;;;;;;;IA6S9C"}