PERFORMANCE

class MultiLevelCache {
  private l1Cache = new Map<string, { data: any, expires: number }>() // In-memory
  private l2Cache: Redis // Distributed cache
  private l3Cache: Database // Persistent storage

  async get<T>(key: string, ttl: number = 300000): Promise<T | null> {
    // L1: Fast in-memory cache
    const l1Data = this.l1Cache.get(key)
    if (l1Data && l1Data.expires > Date.now()) {
      return l1Data.data
    }

    // L2: Distributed cache
    try {
      const l2Data = await this.l2Cache.get(key)
      if (l2Data) {
        // Populate L1 for faster future access
        this.l1Cache.set(key, { data: JSON.parse(l2Data), expires: Date.now() + ttl })
        return JSON.parse(l2Data)
      }
    } catch (error) {
      console.warn('L2 cache unavailable:', error)
    }

    // L3: Database fallback
    const l3Data = await this.l3Cache.findUnique({ where: { key } })
    if (l3Data) {
      // Populate higher caches
      const data = l3Data.value
      this.l1Cache.set(key, { data, expires: Date.now() + ttl })
      await this.l2Cache.setex(key, ttl / 1000, JSON.stringify(data))
      return data
    }

    return null
  }

  async set<T>(key: string, value: T, ttl: number = 300000): Promise<void> {
    const expires = Date.now() + ttl

    // Set all levels
    this.l1Cache.set(key, { data: value, expires })
    await this.l2Cache.setex(key, ttl / 1000, JSON.stringify(value))
    await this.l3Cache.upsert({
      where: { key },
      update: { value, expires },
      create: { key, value, expires }
    })
  }

  // Cleanup expired L1 entries
  cleanup() {
    const now = Date.now()
    for (const [key, value] of this.l1Cache) {
      if (value.expires < now) {
        this.l1Cache.delete(key)
      }
    }
  }
}

// Usage in agent tools
const cache = new MultiLevelCache()

const cachedSearchTool = new Tool({
  name: 'search_with_cache',
  description: 'Search with intelligent caching',
  schema: z.object({
    query: z.string(),
    useCache: z.boolean().default(true)
  }),

  execute: async ({ query, useCache }) => {
    if (useCache) {
      const cached = await cache.get(`search:${query}`)
      if (cached) {
        return JSON.stringify({ ...cached, cached: true })
      }
    }

    // Perform actual search
    const results = await performExpensiveSearch(query)

    // Cache for future use
    await cache.set(`search:${query}`, results, 600000) // 10 minutes

    return JSON.stringify({ ...results, cached: false })
  }
})

class PromptOptimizer {
  // Pre-compile common prompt templates
  private templates = new Map<string, string>()

  constructor() {
    this.compileTemplates()
  }

  private compileTemplates() {
    // Template with placeholders for dynamic content
    this.templates.set('customer_support', `
You are a customer support agent for {{companyName}}.
Customer: {{customerMessage}}

Guidelines:
- Be helpful and friendly
- Use the following context: {{context}}
- Keep responses under 200 words
- If you need more information, ask specific questions

Response:`)

    this.templates.set('data_analysis', `
Analyze this dataset: {{data}}

Requirements:
- Focus on {{focusArea}}
- Provide {{outputFormat}} output
- Highlight {{keyMetrics}}

Analysis:`)
  }

  optimizePrompt(templateName: string, variables: Record<string, string>): string {
    let prompt = this.templates.get(templateName)
    if (!prompt) throw new Error(`Unknown template: ${templateName}`)

    // Replace variables
    for (const [key, value] of Object.entries(variables)) {
      const placeholder = '{{' + key + '}}'
      prompt = prompt.split(placeholder).join(value)
    }

    // Remove unused variables (cleanup)
    prompt = prompt.replace(/{{[^}]+}}/g, '')

    return prompt.trim()
  }

  // Compress prompt by removing redundant information
  compressPrompt(prompt: string): string {
    return prompt
      // Remove excessive whitespace
      .replace(/[\n\r]+/g, '\n')
      .replace(/[ \t]+/g, ' ')
      // Remove redundant phrases
      .replace(/please assist me with/g, 'help with')
      .replace(/I would like to/g, 'I want to')
      // Truncate if too long (keep essential parts)
      .substring(0, 8000) // Leave room for response
  }
}

// Usage
const optimizer = new PromptOptimizer()

const agent = new Agent({
  name: 'optimized-agent',
  model: 'gpt-4',
  systemPrompt: optimizer.optimizePrompt('customer_support', {
    companyName: 'Acme Corp',
    context: 'Product returns within 30 days',
    customerMessage: 'I want to return my order'
  })
})

class ParallelProcessor {
  async processInParallel<T, R>(
    items: T[],
    processor: (item: T) => Promise<R>,
    options: {
      concurrency: number
      onProgress?: (completed: number, total: number) => void
      timeout?: number
    }
  ): Promise<R[]> {
    const results: R[] = []
    const semaphore = new Semaphore(options.concurrency)

    const processItem = async (item: T, index: number): Promise<void> => {
      await semaphore.acquire()

      try {
        const timeoutPromise = options.timeout
          ? Promise.race([
              processor(item),
              new Promise<never>((_, reject) =>
                setTimeout(() => reject(new Error('Timeout')), options.timeout)
              )
            ])
          : processor(item)

        const result = await timeoutPromise
        results[index] = result
        options.onProgress?.(results.filter(r => r !== undefined).length, items.length)

      } finally {
        semaphore.release()
      }
    }

    // Start all operations
    const promises = items.map((item, index) => processItem(item, index))

    // Wait for all to complete
    await Promise.allSettled(promises)

    return results
  }
}

class Semaphore {
  private permits: number
  private waitQueue: Array<() => void> = []

  constructor(permits: number) {
    this.permits = permits
  }

  async acquire(): Promise<void> {
    if (this.permits > 0) {
      this.permits--
      return
    }

    return new Promise(resolve => {
      this.waitQueue.push(resolve)
    })
  }

  release(): void {
    this.permits++
    if (this.waitQueue.length > 0) {
      const resolve = this.waitQueue.shift()!
      this.permits--
      resolve()
    }
  }
}

// Usage in agent tools
const processor = new ParallelProcessor()

const batchAnalysisTool = new Tool({
  name: 'analyze_multiple_documents',
  description: 'Analyze multiple documents in parallel',
  schema: z.object({
    documents: z.array(z.string()),
    analysisType: z.enum(['summary', 'sentiment', 'keywords'])
  }),

  execute: async ({ documents, analysisType }) => {
    const results = await processor.processInParallel(
      documents,
      async (doc) => {
        // Each document analysis runs in parallel
        return await analyzeDocument(doc, analysisType)
      },
      {
        concurrency: 5, // Max 5 concurrent analyses
        timeout: 30000, // 30 second timeout per document
        onProgress: (completed, total) => {
          console.log(`Progress: ${completed}/${total} documents analyzed`)
        }
      }
    )

    return JSON.stringify({
      totalDocuments: documents.length,
      completedAnalyses: results.length,
      results
    })
  }
})