chore: rate limits from db

+ akashchat migration

Author: nick134-bit

components/chat/chat-sidebar.tsx

@@ -706,13 +706,13 @@ export function ChatSidebar({
                   />
                 </div>
 
-                <Link href="https://chatapi.akash.network" target="_blank" rel="noopener noreferrer">
+                <Link href="https://akashml.com" target="_blank" rel="noopener noreferrer">
                   <Button
                     variant="ghost"
                     className="w-full justify-start gap-2 h-8 px-2 text-sm font-light hover:bg-white dark:hover:bg-accent hover:text-accent-foreground"
                   >
                     <PlugZap className="w-3.5 h-3.5" />
-                    <span>AkashChat API</span>
+                    <span>API Access</span>
                   </Button>
                 </Link>
 

components/models/model-detail-client.tsx

@@ -230,6 +230,18 @@ export function ModelDetailClient({ modelId, model: serverModel, modelWithAccess
                   </Button>
                 )}
 
+                {/* API Access button */}
+                <Button
+                  asChild
+                  className="w-full text-md flex items-center justify-center gap-2 py-6 hover:bg-border"
+                  variant="outline"
+                >
+                  <Link href="https://akashml.com" target="_blank" rel="noopener noreferrer" aria-label="API Access">
+                    API Access
+                    <ArrowRight className="h-5 w-5 ml-1" />
+                  </Link>
+                </Button>
+                
                 {/* Status messages based on access control */}
                 {modelWithAccess?.action_button === 'start_chat' && modelWithAccess?.action_text === 'Unavailable' && (
                   <p className="text-sm text-muted-foreground mt-2 text-center">

lib/rate-limit.ts

@@ -1,4 +1,4 @@
-import { getUserTier, getModelByModelId } from './database';
+import { getUserTier, getModelByModelId, type UserTier } from './database';
 import redis from './redis';
 
 const MAX_TOKENS = parseInt(process.env.RATE_LIMIT_ANONYMOUS_TOKENS || '25000');
@@ -23,18 +23,18 @@ export interface RateLimit {
 export function formatTimeUntilReset(resetTime: Date): string {
   const now = new Date();
   const diff = resetTime.getTime() - now.getTime();
-  
+
   if (diff <= 0) {
     return 'now';
   }
-  
+
   const hours = Math.floor(diff / (1000 * 60 * 60));
   const minutes = Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60));
-  
+
   if (hours > 0) {
     return `${hours}h ${minutes}m`;
   }
-  
+
   return `${minutes}m`;
 }
 
@@ -44,6 +44,39 @@ export interface RateLimitConfig {
   keyPrefix?: string;
 }
 
+// Cache for permissionless tier - initialized on first use
+let permissionlessTierCache: UserTier | null = null;
+let permissionlessTierCachePromise: Promise<UserTier | null> | null = null;
+
+/**
+ * Get cached permissionless tier from database
+ */
+async function getPermissionlessTier(): Promise<UserTier | null> {
+  if (permissionlessTierCache) {
+    return permissionlessTierCache;
+  }
+
+  // If already fetching, return the existing promise
+  if (permissionlessTierCachePromise) {
+    return permissionlessTierCachePromise;
+  }
+
+  // Start fetching and cache the promise
+  permissionlessTierCachePromise = getUserTier(null)
+    .then(tier => {
+      permissionlessTierCache = tier;
+      permissionlessTierCachePromise = null;
+      return tier;
+    })
+    .catch(error => {
+      console.error('Failed to cache permissionless tier:', error);
+      permissionlessTierCachePromise = null;
+      return null;
+    });
+
+  return permissionlessTierCachePromise;
+}
+
 export const DEFAULT_ANONYMOUS_LIMIT: RateLimitConfig = {
   maxTokens: MAX_TOKENS,
   windowMs: 4 * 60 * 60 * 1000, // 4 hours
@@ -72,22 +105,50 @@ export function getRateLimitConfig(isAuthenticated: boolean): RateLimitConfig {
  */
 export async function getRateLimitConfigForUser(userId: string | null): Promise<RateLimitConfig> {
   if (!userId) {
+    // Use cached permissionless tier from database
+    const permissionlessTier = await getPermissionlessTier();
+    if (permissionlessTier) {
+      return {
+        maxTokens: permissionlessTier.token_limit,
+        windowMs: permissionlessTier.rate_limit_window_ms,
+        keyPrefix: 'token_limit:anonymous:',
+      };
+    }
+    // Fallback to env var if database fetch fails
     return DEFAULT_ANONYMOUS_LIMIT;
   }
-  
+
   try {
     const userTier = await getUserTier(userId);
     if (!userTier) {
+      // User has no tier, use permissionless tier
+      const permissionlessTier = await getPermissionlessTier();
+      if (permissionlessTier) {
+        return {
+          maxTokens: permissionlessTier.token_limit,
+          windowMs: permissionlessTier.rate_limit_window_ms,
+          keyPrefix: 'token_limit:user:',
+        };
+      }
       return DEFAULT_ANONYMOUS_LIMIT;
     }
-    
+
     return {
       maxTokens: userTier.token_limit,
       windowMs: userTier.rate_limit_window_ms,
       keyPrefix: 'token_limit:user:',
     };
   } catch (error) {
     console.error('Error fetching user tier for rate limiting:', error);
+    // Try to use cached permissionless tier as fallback
+    const permissionlessTier = await getPermissionlessTier();
+    if (permissionlessTier) {
+      return {
+        maxTokens: permissionlessTier.token_limit,
+        windowMs: permissionlessTier.rate_limit_window_ms,
+        keyPrefix: 'token_limit:user:',
+      };
+    }
     return DEFAULT_ANONYMOUS_LIMIT;
   }
 }