Rate Limits & Token Usage

async function makeRequestWithBackoff(request, maxRetries = 3) {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      return await fetch('/api/v1/chat', request);
    } catch (error) {
      if (error.status === 429 && attempt < maxRetries) {
        const delay = Math.pow(2, attempt) * 1000; // 1s, 2s, 4s, 8s
        await new Promise(resolve => setTimeout(resolve, delay));
        continue;
      }
      throw error;
    }
  }
}

// ❌ Inefficient - Too verbose (150+ tokens)
const verbosePrompt = `
I would like you to please help me write a very professional business email 
that I need to send to my client regarding the project status update that we 
discussed in our previous meeting last week. The email should be formal and 
include all the necessary details about the progress we have made so far and 
what the next steps will be. Please make sure it sounds professional and 
includes appropriate business language.
`;

// ✅ Efficient - Concise and clear (15-20 tokens)
const efficientPrompt = `Write a professional email to a client with a project status update. Include progress made and next steps.`;

// ✅ Good - Set context once with system message
const messages = [
  {
    role: 'system',
    content: 'You are a professional email writer. Write clear, polite emails.'
  },
  {
    role: 'user',
    content: 'Write a follow-up email after a job interview.'
  }
];

// ❌ Less efficient - Repeat instructions in every user message
const messagesVerbose = [
  {
    role: 'user',
    content: 'You are a professional email writer. Write a clear, polite follow-up email after a job interview.'
  }
];

function trimConversation(messages, maxTokens = 2000) {
  let totalTokens = 0;
  const trimmedMessages = [];
  
  // Always keep system message if present
  if (messages[0]?.role === 'system') {
    trimmedMessages.push(messages[0]);
    totalTokens += estimateTokens(messages[0].content);
  }
  
  // Add messages from the end, working backwards
  for (let i = messages.length - 1; i >= 1; i--) {
    const message = messages[i];
    const messageTokens = estimateTokens(message.content);
    
    if (totalTokens + messageTokens > maxTokens) break;
    
    trimmedMessages.unshift(message);
    totalTokens += messageTokens;
  }
  
  return trimmedMessages;
}

function estimateTokens(text) {
  return Math.ceil(text.length / 4);
}

// ❌ Multiple separate requests (3 API calls)
const requests = [
  'Write a haiku about coding',
  'Write a haiku about design', 
  'Write a haiku about teamwork'
];

for (const prompt of requests) {
  await apiCall(prompt);
}

// ✅ Single batch request (1 API call)
const batchPrompt = `Write three haikus about:
1. Coding
2. Design  
3. Teamwork

Format each haiku clearly with numbers.`;

await apiCall(batchPrompt);

class APIQueue {
  constructor(maxConcurrent = 3, delayBetweenRequests = 100) {
    this.queue = [];
    this.running = 0;
    this.maxConcurrent = maxConcurrent;
    this.delay = delayBetweenRequests;
  }

  async add(requestFn) {
    return new Promise((resolve, reject) => {
      this.queue.push({ requestFn, resolve, reject });
      this.process();
    });
  }

  async process() {
    if (this.running >= this.maxConcurrent || this.queue.length === 0) {
      return;
    }

    this.running++;
    const { requestFn, resolve, reject } = this.queue.shift();

    try {
      const result = await requestFn();
      resolve(result);
    } catch (error) {
      reject(error);
    } finally {
      this.running--;
      setTimeout(() => this.process(), this.delay);
    }
  }
}

// Usage
const apiQueue = new APIQueue(3, 100); // Max 3 concurrent, 100ms delay

class ResponseCache {
  constructor(ttl = 3600000) { // 1 hour default
    this.cache = new Map();
    this.ttl = ttl;
  }

  generateKey(messages) {
    return JSON.stringify(messages);
  }

  get(messages) {
    const key = this.generateKey(messages);
    const cached = this.cache.get(key);
    
    if (cached && Date.now() - cached.timestamp < this.ttl) {
      return cached.response;
    }
    
    if (cached) {
      this.cache.delete(key); // Remove expired entry
    }
    
    return null;
  }

  set(messages, response) {
    const key = this.generateKey(messages);
    this.cache.set(key, {
      response,
      timestamp: Date.now()
    });
  }
}

// Usage
const cache = new ResponseCache();

async function cachedApiCall(messages) {
  // Check cache first
  let response = cache.get(messages);
  if (response) {
    console.log('Cache hit!');
    return response;
  }
  
  // Make API call
  response = await makeApiCall(messages);
  cache.set(messages, response);
  return response;
}

// Check usage before making requests
async function safeApiCall(messages) {
  try {
    // Check usage first (implement based on your tracking)
    const usage = await getCurrentUsage();
    if (usage.percentage > 95) {
      throw new Error('Approaching token limit. Request not sent.');
    }
    
    return await chatAPI(messages);
  } catch (error) {
    if (error.message.includes('Token limit exceeded')) {
      return 'Sorry, the workspace has reached its monthly token limit. Please try again next month or upgrade your plan.';
    }
    throw error;
  }
}

function optimizeConversation(messages, maxTokens = 2000) {
  // Keep system message and recent conversation
  const systemMsg = messages.find(m => m.role === 'system');
  const otherMessages = messages.filter(m => m.role !== 'system');
  
  // Calculate tokens and trim if needed
  let totalTokens = systemMsg ? estimateTokens(systemMsg.content) : 0;
  const optimizedMessages = systemMsg ? [systemMsg] : [];
  
  // Add messages from most recent backwards
  for (let i = otherMessages.length - 1; i >= 0; i--) {
    const message = otherMessages[i];
    const messageTokens = estimateTokens(message.content);
    
    if (totalTokens + messageTokens > maxTokens) break;
    
    optimizedMessages.push(message);
    totalTokens += messageTokens;
  }
  
  // Reverse to maintain chronological order (except system message)
  if (systemMsg) {
    return [systemMsg, ...optimizedMessages.slice(1).reverse()];
  }
  return optimizedMessages.reverse();
}

// More accurate token estimation
function estimateTokens(text) {
  // Account for different token patterns
  const words = text.split(/\s+/);
  const avgTokensPerWord = 1.3; // More accurate estimate
  return Math.ceil(words.length * avgTokensPerWord);
}

// Pre-flight token check
function preflightCheck(messages, maxTokens = 4000) {
  const totalTokens = messages.reduce((sum, msg) => 
    sum + estimateTokens(msg.content), 0
  );
  
  if (totalTokens > maxTokens) {
    throw new Error(`Request too large: ${totalTokens} tokens (max: ${maxTokens})`);
  }
  
  return totalTokens;
}