@lastbrain/module-ai 2.0.26 → 2.0.30

package/dist/api/public/token-pricing.js

@@ -0,0 +1,168 @@
+/**
+ * GET /api/ai/public/token-pricing
+ * Returns token pricing information for all models
+ * Single source of truth for client-side pricing display
+ */
+import { NextResponse } from "next/server";
+import { logger } from "@lastbrain/core";
+import { getSupabaseServiceClient } from "@lastbrain/core/server";
+import { fetchGatewayModels } from "../../server/gateway-service";
+import { computeProviderCostUsd, estimateDebitTokens, } from "../../server/billing";
+export async function GET(request) {
+    try {
+        // Get pack ID from query params (optional)
+        const url = new URL(request.url);
+        const packId = url.searchParams.get("packId");
+        // Get pack info from database
+        const supabase = await getSupabaseServiceClient();
+        let packInfo;
+        if (packId) {
+            const { data: pack } = await supabase
+                .from("token_packs")
+                .select("tokens, price_cents, currency, pack_coef")
+                .eq("id", packId)
+                .eq("is_active", true)
+                .single();
+            if (pack) {
+                packInfo = {
+                    tokens: pack.tokens,
+                    price_usd: pack.price_cents / 100,
+                    coef: pack.pack_coef || 1.35, // Use DB value or fallback
+                };
+            }
+            else {
+                // Fallback to best pack
+                packInfo = await getBestPack(supabase);
+            }
+        }
+        else {
+            // Use best pack (lowest $/token)
+            packInfo = await getBestPack(supabase);
+        }
+        // Fetch models from gateway (internal, with pricing)
+        const gatewayResponse = await fetchGatewayModels();
+        // Calculate pricing for all models
+        const providersWithPricing = gatewayResponse.providers.map((provider) => {
+            const modelsWithPricing = provider.models.map((model) => {
+                // Map Gateway types to our internal types
+                const normalizedType = model.type === "language" ? "text" : model.type;
+                // Only calculate pricing for supported types
+                if (normalizedType !== "text" && normalizedType !== "image") {
+                    return {
+                        modelId: model.id,
+                        modelName: model.name,
+                        type: model.type,
+                        provider: model.provider,
+                        estimatedTokens: null,
+                        displayPrice: "N/A",
+                        available: false,
+                    };
+                }
+                const providerPricing = {
+                    // Gateway prices are in $/token (not $/M)
+                    inputUsdPerToken: model.pricing?.input
+                        ? parseFloat(model.pricing.input.toString())
+                        : undefined,
+                    outputUsdPerToken: model.pricing?.output
+                        ? parseFloat(model.pricing.output.toString())
+                        : undefined,
+                    imageUsdPerImage: model.pricing?.image
+                        ? parseFloat(model.pricing.image.toString())
+                        : undefined,
+                };
+                let estimatedTokens = null;
+                let displayPrice = "N/A";
+                let inputSellUsdPerMToken;
+                let outputSellUsdPerMToken;
+                if (normalizedType === "text") {
+                    // Estimate for 500K input + 500K output
+                    const usage = {
+                        inputTokens: 500_000,
+                        outputTokens: 500_000,
+                    };
+                    const providerCost = computeProviderCostUsd(usage, providerPricing);
+                    if (providerCost > 0) {
+                        estimatedTokens = estimateDebitTokens(providerCost, packInfo.coef, packInfo.tokens, packInfo.price_usd);
+                        displayPrice = `~${estimatedTokens.toLocaleString()} tokens/1M`;
+                        // Sell prices with markup
+                        if (providerPricing.inputUsdPerToken) {
+                            inputSellUsdPerMToken =
+                                providerPricing.inputUsdPerToken * 1_000_000 * packInfo.coef;
+                        }
+                        if (providerPricing.outputUsdPerToken) {
+                            outputSellUsdPerMToken =
+                                providerPricing.outputUsdPerToken * 1_000_000 * packInfo.coef;
+                        }
+                    }
+                }
+                else if (normalizedType === "image") {
+                    // Estimate for 1 image
+                    const usage = { images: 1 };
+                    const providerCost = computeProviderCostUsd(usage, providerPricing);
+                    if (providerCost > 0) {
+                        estimatedTokens = estimateDebitTokens(providerCost, packInfo.coef, packInfo.tokens, packInfo.price_usd);
+                        displayPrice = `${estimatedTokens.toLocaleString()} tokens/img`;
+                    }
+                }
+                return {
+                    modelId: model.id,
+                    modelName: model.name,
+                    type: model.type,
+                    provider: model.provider,
+                    estimatedTokens,
+                    displayPrice,
+                    available: estimatedTokens !== null,
+                    inputSellUsdPerMToken,
+                    outputSellUsdPerMToken,
+                    imageSellUsd: providerPricing.imageUsdPerImage
+                        ? providerPricing.imageUsdPerImage * packInfo.coef
+                        : undefined,
+                };
+            });
+            return {
+                name: provider.name,
+                display_name: provider.display_name,
+                models: modelsWithPricing,
+            };
+        });
+        return NextResponse.json({
+            config: {
+                packTokens: packInfo.tokens,
+                packPriceUsd: packInfo.price_usd,
+                tokenPriceUsd: packInfo.price_usd / packInfo.tokens,
+                markupCoef: packInfo.coef,
+            },
+            providers: providersWithPricing,
+        });
+    }
+    catch (error) {
+        logger.error("[public/token-pricing] Error:", error);
+        return NextResponse.json({ error: error.message || "Internal server error" }, { status: 500 });
+    }
+}
+// Helper to get best pack (lowest $/token)
+async function getBestPack(supabase) {
+    const { data: packs } = await supabase
+        .from("token_packs")
+        .select("tokens, price_cents, pack_coef")
+        .eq("is_active", true);
+    if (!packs || packs.length === 0) {
+        // Fallback
+        return { tokens: 2_000_000, price_usd: 50, coef: 1.35 };
+    }
+    // Find pack with lowest $/token
+    let bestPack = packs[0];
+    let bestRate = packs[0].price_cents / 100 / packs[0].tokens;
+    for (const pack of packs) {
+        const rate = pack.price_cents / 100 / pack.tokens;
+        if (rate < bestRate) {
+            bestRate = rate;
+            bestPack = pack;
+        }
+    }
+    return {
+        tokens: bestPack.tokens,
+        price_usd: bestPack.price_cents / 100,
+        coef: bestPack.pack_coef || 1.35, // Use DB value or fallback
+    };
+}

package/dist/api/public/v1/_lib/artifacts.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Helper functions for AI artifacts storage
+ */
+interface ApiKey {
+    id: string;
+    owner_id: string;
+    name: string;
+}
+interface ArtifactOptions {
+    apiKey: ApiKey;
+    kind: "text" | "image" | "pdf" | "file";
+    endpoint: string;
+    provider?: string | null;
+    model?: string | null;
+    tokensTotal?: number | null;
+    statusCode?: number;
+    textContent?: string;
+    fileBuffer?: Buffer;
+    mimeType?: string;
+    ext?: string;
+    meta?: Record<string, any>;
+}
+interface StorageResult {
+    success: boolean;
+    artifactId?: string;
+    storagePath?: string;
+    error?: string;
+}
+/**
+ * Check if user has store_outputs enabled
+ */
+export declare function shouldStoreOutputs(ownerId: string, overrideStoreOutputs?: boolean): Promise<boolean>;
+/**
+ * Create artifact record in database
+ */
+export declare function createArtifact(options: ArtifactOptions): Promise<StorageResult>;
+/**
+ * Generate signed URL for file download
+ */
+export declare function getSignedDownloadUrl(storagePath: string, expiresIn?: number): Promise<{
+    url: string | null;
+    error?: string;
+}>;
+/**
+ * Delete artifact and its storage file
+ */
+export declare function deleteArtifact(artifactId: string, ownerId: string): Promise<{
+    success: boolean;
+    error?: string;
+}>;
+export {};
+//# sourceMappingURL=artifacts.d.ts.map

package/dist/api/public/v1/_lib/artifacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifacts.d.ts","sourceRoot":"","sources":["../../../../../src/api/public/v1/_lib/artifacts.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,UAAU,MAAM;IACd,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,UAAU,eAAe;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC5B;AAED,UAAU,aAAa;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAuBD;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,MAAM,EACf,oBAAoB,CAAC,EAAE,OAAO,GAC7B,OAAO,CAAC,OAAO,CAAC,CA8BlB;AAED;;GAEG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,aAAa,CAAC,CA+GxB;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,WAAW,EAAE,MAAM,EACnB,SAAS,SAAK,GACb,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAqBjD;AAED;;GAEG;AACH,wBAAsB,cAAc,CAClC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAgD/C"}

package/dist/api/public/v1/_lib/artifacts.js

@@ -0,0 +1,217 @@
+/**
+ * Helper functions for AI artifacts storage
+ */
+import { logger } from "@lastbrain/core";
+import { getSupabaseServiceClient } from "@lastbrain/core/server";
+/**
+ * Sanitize API key name for storage path
+ */
+function sanitizeApiKeyName(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, "-")
+        .replace(/-+/g, "-")
+        .substring(0, 50);
+}
+/**
+ * Get month-year folder (mm-yyyy)
+ */
+function getMonthYearFolder() {
+    const now = new Date();
+    const month = String(now.getMonth() + 1).padStart(2, "0");
+    const year = now.getFullYear();
+    return `${month}-${year}`;
+}
+/**
+ * Check if user has store_outputs enabled
+ */
+export async function shouldStoreOutputs(ownerId, overrideStoreOutputs) {
+    // If explicitly provided in request, use that value
+    if (overrideStoreOutputs !== undefined) {
+        return overrideStoreOutputs;
+    }
+    try {
+        const supabase = getSupabaseServiceClient();
+        const { data, error } = await supabase
+            .from("user_ai_settings")
+            .select("store_outputs")
+            .eq("owner_id", ownerId)
+            .single();
+        if (error || !data) {
+            logger.debug("[artifacts] No settings found for user, defaulting to false", {
+                ownerId,
+            });
+            return false;
+        }
+        return data.store_outputs === true;
+    }
+    catch (error) {
+        logger.error("[artifacts] Error checking store_outputs", error);
+        return false;
+    }
+}
+/**
+ * Create artifact record in database
+ */
+export async function createArtifact(options) {
+    const { apiKey, kind, endpoint, provider, model, tokensTotal, statusCode = 200, textContent, fileBuffer, mimeType, ext, meta = {}, } = options;
+    try {
+        const supabase = getSupabaseServiceClient();
+        const artifactId = crypto.randomUUID();
+        // Sanitize API key name for path
+        const apiKeyName = apiKey.name
+            ? sanitizeApiKeyName(apiKey.name)
+            : "default";
+        const monthYear = getMonthYearFolder();
+        let storagePath = null;
+        let sizeBytes = null;
+        // Handle file storage (image, pdf, file)
+        if (kind !== "text" && fileBuffer) {
+            const extension = ext || "bin";
+            storagePath = `${apiKey.owner_id}/${apiKeyName}/${monthYear}/${artifactId}.${extension}`;
+            try {
+                const { error: uploadError } = await supabase.storage
+                    .from("app")
+                    .upload(storagePath, fileBuffer, {
+                    contentType: mimeType || "application/octet-stream",
+                    upsert: false,
+                });
+                if (uploadError) {
+                    logger.error("[artifacts] Storage upload failed", {
+                        error: uploadError,
+                        path: storagePath,
+                    });
+                    // Continue anyway, will store metadata without file
+                    storagePath = null;
+                }
+                else {
+                    sizeBytes = fileBuffer.length;
+                }
+            }
+            catch (uploadError) {
+                logger.error("[artifacts] Storage upload exception", uploadError);
+                storagePath = null;
+            }
+        }
+        // Insert artifact record
+        const { data, error } = await supabase
+            .from("ai_artifacts")
+            .insert({
+            id: artifactId,
+            owner_id: apiKey.owner_id,
+            api_key_id: apiKey.id,
+            api_key_name: apiKeyName,
+            kind,
+            provider,
+            model,
+            endpoint,
+            tokens_total: tokensTotal,
+            status_code: statusCode,
+            text_content: kind === "text" ? textContent : null,
+            storage_bucket: storagePath ? "app" : null,
+            storage_path: storagePath,
+            mime_type: mimeType || null,
+            size_bytes: sizeBytes,
+            meta,
+        })
+            .select("id, storage_path")
+            .single();
+        if (error) {
+            logger.error("[artifacts] Failed to insert artifact", {
+                error,
+                artifactId,
+            });
+            return {
+                success: false,
+                error: error.message,
+            };
+        }
+        logger.info("[artifacts] Artifact created", {
+            artifactId,
+            kind,
+            storagePath,
+        });
+        return {
+            success: true,
+            artifactId: data.id,
+            storagePath: data.storage_path || undefined,
+        };
+    }
+    catch (error) {
+        logger.error("[artifacts] Unexpected error creating artifact", error);
+        return {
+            success: false,
+            error: error.message,
+        };
+    }
+}
+/**
+ * Generate signed URL for file download
+ */
+export async function getSignedDownloadUrl(storagePath, expiresIn = 60) {
+    try {
+        const supabase = getSupabaseServiceClient();
+        const { data, error } = await supabase.storage
+            .from("app")
+            .createSignedUrl(storagePath, expiresIn);
+        if (error) {
+            logger.error("[artifacts] Failed to generate signed URL", {
+                error,
+                path: storagePath,
+            });
+            return { url: null, error: error.message };
+        }
+        return { url: data.signedUrl };
+    }
+    catch (error) {
+        logger.error("[artifacts] Exception generating signed URL", error);
+        return { url: null, error: error.message };
+    }
+}
+/**
+ * Delete artifact and its storage file
+ */
+export async function deleteArtifact(artifactId, ownerId) {
+    try {
+        const supabase = getSupabaseServiceClient();
+        // Get artifact first to check ownership and get storage path
+        const { data: artifact, error: fetchError } = await supabase
+            .from("ai_artifacts")
+            .select("owner_id, storage_path, storage_bucket")
+            .eq("id", artifactId)
+            .single();
+        if (fetchError || !artifact) {
+            return { success: false, error: "Artifact not found" };
+        }
+        if (artifact.owner_id !== ownerId) {
+            return { success: false, error: "Unauthorized" };
+        }
+        // Delete file from storage if exists
+        if (artifact.storage_path && artifact.storage_bucket) {
+            try {
+                await supabase.storage
+                    .from(artifact.storage_bucket)
+                    .remove([artifact.storage_path]);
+            }
+            catch (storageError) {
+                logger.error("[artifacts] Failed to delete storage file", storageError);
+                // Continue anyway to delete DB record
+            }
+        }
+        // Delete database record
+        const { error: deleteError } = await supabase
+            .from("ai_artifacts")
+            .delete()
+            .eq("id", artifactId);
+        if (deleteError) {
+            logger.error("[artifacts] Failed to delete artifact record", deleteError);
+            return { success: false, error: deleteError.message };
+        }
+        logger.info("[artifacts] Artifact deleted", { artifactId });
+        return { success: true };
+    }
+    catch (error) {
+        logger.error("[artifacts] Exception deleting artifact", error);
+        return { success: false, error: error.message };
+    }
+}

package/dist/api/public/v1/_lib/auth.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Authentication and authorization helpers for public API v1
+ */
+export interface ApiKeyData {
+    id: string;
+    owner_id: string;
+    name: string;
+    prefix: string;
+    env: string;
+    scopes: string[];
+    rate_limit_rpm: number;
+    daily_token_limit: bigint | null;
+    is_active: boolean;
+    last_used_at: string | null;
+    created_at: string;
+}
+export interface ValidateApiKeyResult {
+    success: boolean;
+    error?: string;
+    errorCode?: string;
+    apiKey?: ApiKeyData;
+}
+/**
+ * Hash API key for lookup
+ */
+export declare function hashApiKey(apiKey: string): string;
+/**
+ * Validate API key from Authorization header
+ */
+export declare function validateApiKey(authHeader: string | null): Promise<ValidateApiKeyResult>;
+/**
+ * Check if API key has required scope
+ */
+export declare function hasScope(apiKey: ApiKeyData, requiredScope: string): boolean;
+/**
+ * Verify API key has required scope, returns error if not
+ */
+export declare function verifyScope(apiKey: ApiKeyData, requiredScope: string): {
+    success: boolean;
+    error?: string;
+    errorCode?: string;
+};
+//# sourceMappingURL=auth.d.ts.map

package/dist/api/public/v1/_lib/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../../../../src/api/public/v1/_lib/auth.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,UAAU,CAAC;CACrB;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED;;GAEG;AACH,wBAAsB,cAAc,CAClC,UAAU,EAAE,MAAM,GAAG,IAAI,GACxB,OAAO,CAAC,oBAAoB,CAAC,CAgF/B;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAE3E;AAED;;GAEG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,UAAU,EAClB,aAAa,EAAE,MAAM,GACpB;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAS1D"}

package/dist/api/public/v1/_lib/auth.js

@@ -0,0 +1,108 @@
+/**
+ * Authentication and authorization helpers for public API v1
+ */
+import { getSupabaseServiceClient } from "@lastbrain/core/server";
+import { logger } from "@lastbrain/core";
+import { createHash } from "crypto";
+/**
+ * Hash API key for lookup
+ */
+export function hashApiKey(apiKey) {
+    return createHash("sha256").update(apiKey).digest("hex");
+}
+/**
+ * Validate API key from Authorization header
+ */
+export async function validateApiKey(authHeader) {
+    if (!authHeader) {
+        return {
+            success: false,
+            error: "Missing Authorization header",
+            errorCode: "MISSING_API_KEY",
+        };
+    }
+    const parts = authHeader.split(" ");
+    if (parts.length !== 2 || parts[0] !== "Bearer") {
+        return {
+            success: false,
+            error: "Invalid Authorization header format. Expected: Bearer <api_key>",
+            errorCode: "INVALID_API_KEY",
+        };
+    }
+    const rawKey = parts[1];
+    if (!rawKey || rawKey.length < 32) {
+        return {
+            success: false,
+            error: "Invalid API key format",
+            errorCode: "INVALID_API_KEY",
+        };
+    }
+    try {
+        const keyHash = hashApiKey(rawKey);
+        const supabase = await getSupabaseServiceClient();
+        const { data: apiKey, error } = await supabase
+            .from("api_keys")
+            .select("*")
+            .eq("key_hash", keyHash)
+            .single();
+        if (error || !apiKey) {
+            logger.warn("[validateApiKey] API key not found", { keyHash });
+            return {
+                success: false,
+                error: "Invalid API key",
+                errorCode: "INVALID_API_KEY",
+            };
+        }
+        if (!apiKey.is_active) {
+            logger.warn("[validateApiKey] API key is inactive", {
+                id: apiKey.id,
+                owner_id: apiKey.owner_id,
+            });
+            return {
+                success: false,
+                error: "API key is inactive",
+                errorCode: "INACTIVE_API_KEY",
+            };
+        }
+        // Parse scopes from JSONB
+        const scopes = Array.isArray(apiKey.scopes)
+            ? apiKey.scopes
+            : typeof apiKey.scopes === "string"
+                ? JSON.parse(apiKey.scopes)
+                : [];
+        return {
+            success: true,
+            apiKey: {
+                ...apiKey,
+                scopes,
+            },
+        };
+    }
+    catch (error) {
+        logger.error("[validateApiKey] Error validating API key", error);
+        return {
+            success: false,
+            error: "Internal error validating API key",
+            errorCode: "INTERNAL_ERROR",
+        };
+    }
+}
+/**
+ * Check if API key has required scope
+ */
+export function hasScope(apiKey, requiredScope) {
+    return apiKey.scopes.includes(requiredScope);
+}
+/**
+ * Verify API key has required scope, returns error if not
+ */
+export function verifyScope(apiKey, requiredScope) {
+    if (!hasScope(apiKey, requiredScope)) {
+        return {
+            success: false,
+            error: `Missing required scope: ${requiredScope}`,
+            errorCode: "INSUFFICIENT_SCOPE",
+        };
+    }
+    return { success: true };
+}

package/dist/api/public/v1/_lib/errors.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Standard error codes and JSON error responses for public API v1
+ */
+export type ErrorCode = "MISSING_API_KEY" | "INVALID_API_KEY" | "INACTIVE_API_KEY" | "INSUFFICIENT_SCOPE" | "INSUFFICIENT_TOKENS" | "RATE_LIMIT_EXCEEDED" | "DAILY_LIMIT_EXCEEDED" | "VALIDATION_ERROR" | "PROVIDER_ERROR" | "INTERNAL_ERROR" | "INVALID_CREDENTIALS" | "USER_NOT_FOUND";
+export interface ApiError {
+    error: {
+        code: ErrorCode;
+        message: string;
+        request_id: string;
+        action_url?: string;
+    };
+}
+export declare function createErrorResponse(code: ErrorCode, message: string, requestId: string, actionUrl?: string, status?: number): {
+    response: ApiError;
+    status: number;
+};
+//# sourceMappingURL=errors.d.ts.map

package/dist/api/public/v1/_lib/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../../src/api/public/v1/_lib/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,SAAS,GACjB,iBAAiB,GACjB,iBAAiB,GACjB,kBAAkB,GAClB,oBAAoB,GACpB,qBAAqB,GACrB,qBAAqB,GACrB,sBAAsB,GACtB,kBAAkB,GAClB,gBAAgB,GAChB,gBAAgB,GAChB,qBAAqB,GACrB,gBAAgB,CAAC;AAErB,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE;QACL,IAAI,EAAE,SAAS,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;CACH;AAED,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,SAAS,CAAC,EAAE,MAAM,EAClB,MAAM,GAAE,MAAY,GACnB;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAYxC"}

package/dist/api/public/v1/_lib/errors.js

@@ -0,0 +1,16 @@
+/**
+ * Standard error codes and JSON error responses for public API v1
+ */
+export function createErrorResponse(code, message, requestId, actionUrl, status = 400) {
+    return {
+        response: {
+            error: {
+                code,
+                message,
+                request_id: requestId,
+                ...(actionUrl && { action_url: actionUrl }),
+            },
+        },
+        status,
+    };
+}

package/dist/api/public/v1/_lib/log.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Logging utilities for public API v1
+ * Handles ai_call_log inserts and api_keys.last_used_at updates
+ */
+import type { ApiKeyData } from "./auth";
+export interface LogCallParams {
+    apiKeyId: string;
+    ownerId: string;
+    endpoint: string;
+    provider: string | null;
+    model: string | null;
+    tokensIn: number | null;
+    tokensOut: number | null;
+    tokensTotal: number | null;
+    latencyMs: number | null;
+    statusCode: number;
+    errorCode: string | null;
+    requestId: string;
+    meta?: Record<string, unknown>;
+}
+/**
+ * Insert a log entry in ai_call_log
+ */
+export declare function logApiCall(params: LogCallParams): Promise<void>;
+/**
+ * Update api_keys.last_used_at
+ */
+export declare function updateApiKeyLastUsed(apiKey: ApiKeyData): Promise<void>;
+//# sourceMappingURL=log.d.ts.map

package/dist/api/public/v1/_lib/log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../../../../src/api/public/v1/_lib/log.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAEzC,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAED;;GAEG;AACH,wBAAsB,UAAU,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAqCrE;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAkB5E"}