🧠 Contexto Global vs por Agente

// Anatomia completa de um request a API
const messages = [
  // 1. System Prompt (~500-2000 tokens)
  {
    role: 'system',
    content: `Voce e o assistente da plataforma AgentSaaS.
    Regras: responda em portugues, seja direto, nunca invente dados.
    Usuario: ${user.name}, plano ${user.plan}, timezone ${user.tz}.`
  },

  // 2. Historico de conversa (~100-500 tokens por turno)
  { role: 'user', content: 'Quantos emails recebi hoje?' },
  { role: 'assistant', content: 'Deixa eu verificar seus emails.' },

  // 3. Tool Results (~200-5000 tokens por resultado)
  {
    role: 'tool',
    tool_call_id: 'call_abc123',
    content: JSON.stringify({
      total: 12,
      unread: 3,
      important: ['Reuniao amanha 14h', 'Fatura vencendo']
    })
  },

  // 4. Nova mensagem do usuario (~10-500 tokens)
  { role: 'user', content: 'Algum urgente?' }
];

// Token budget: model_limit - system - history - tools = disponivel
// Ex: 128K - 1K - 8K - 3K = 116K disponivel para resposta

// prompts/global.md
# Regras Globais da Plataforma

Voce faz parte da plataforma AgentSaaS.
- Responda sempre em portugues brasileiro
- Nunca invente informacoes. Se nao sabe, diga
- Nunca execute acoes destrutivas sem confirmacao
- Formate respostas para Telegram (texto limpo, sem markdown pesado)
- Proteja dados do usuario. Nunca exponha dados de outros usuarios

---

// prompts/agents/research.md
# Agente de Pesquisa

Voce e o agente de pesquisa da plataforma.
Seu dominio: buscar, analisar e sintetizar informacoes.

## Ferramentas disponiveis
- web_search: buscar na web
- read_url: ler conteudo de uma URL
- summarize: resumir textos longos

## Regras especificas
- Sempre cite a fonte das informacoes
- Priorize fontes oficiais e recentes
- Se os resultados sao ambiguos, apresente as opcoes

---

// prompts/tasks/summarize.md
# Tarefa: Sumarizacao

Para esta tarefa especifica:
- Extraia os 3-5 pontos principais
- Use bullet points
- Limite a resposta a 200 palavras
- Inclua uma frase de conclusao

// lib/prompt-builder.ts
import { readFileSync } from 'fs';
import { join } from 'path';

const PROMPTS_DIR = join(process.cwd(), 'prompts');

export function buildSystemPrompt(
  agentId: string,
  taskType?: string,
  userContext?: Record<string, string>
): string {
  const layers: string[] = [];

  // Nivel 1: Global (sempre presente)
  layers.push(readFileSync(join(PROMPTS_DIR, 'global.md'), 'utf-8'));

  // Nivel 2: Agent role
  const agentPromptPath = join(PROMPTS_DIR, 'agents', `${agentId}.md`);
  try {
    layers.push(readFileSync(agentPromptPath, 'utf-8'));
  } catch {
    // Agent sem prompt especifico usa apenas o global
  }

  // Nivel 3: Task-specific (se aplicavel)
  if (taskType) {
    const taskPromptPath = join(PROMPTS_DIR, 'tasks', `${taskType}.md`);
    try {
      layers.push(readFileSync(taskPromptPath, 'utf-8'));
    } catch {
      // Sem prompt de tarefa especifica
    }
  }

  // Injetar contexto do usuario
  let prompt = layers.join('\n\n---\n\n');
  if (userContext) {
    for (const [key, value] of Object.entries(userContext)) {
      prompt = prompt.replace(`{{${key}}}`, value);
    }
  }

  return prompt;
}

// context/shared.ts - Global Context Store
interface SharedContext {
  user: {
    id: string;
    name: string;
    email: string;
    plan: 'free' | 'pro' | 'enterprise';
    timezone: string;
    locale: string;
  };
  limits: {
    requestsRemaining: number;
    tokensRemaining: number;
    canUseTools: boolean;
    canUsePremiumModels: boolean;
  };
  preferences: {
    responseFormat: 'concise' | 'detailed';
    notifyVia: 'telegram' | 'email' | 'both';
    topics: string[];
  };
}

// Implementacao com diferentes backends
class ContextStore {
  // Em memoria (dev, single-instance)
  private cache = new Map<string, SharedContext>();

  // Redis (producao, multi-instance)
  // private redis: Redis;

  async get(userId: string): Promise<SharedContext> {
    // 1. Verificar cache em memoria (mais rapido)
    if (this.cache.has(userId)) return this.cache.get(userId)!;

    // 2. Verificar Redis (compartilhado entre instances)
    // const cached = await this.redis.get(`ctx:${userId}`);
    // if (cached) return JSON.parse(cached);

    // 3. Carregar do banco (source of truth)
    const context = await this.loadFromDB(userId);
    this.cache.set(userId, context);
    return context;
  }

  async update(userId: string, partial: Partial<SharedContext>) {
    const current = await this.get(userId);
    const updated = { ...current, ...partial };
    this.cache.set(userId, updated);
    // await this.redis.set(`ctx:${userId}`, JSON.stringify(updated), 'EX', 3600);
    await this.saveToDB(userId, updated);
  }
}

// agents/base.ts - Agent com contexto isolado
interface AgentConfig {
  id: string;
  name: string;
  provider: AIProvider;
  tools: Tool[];
  memoryNamespace: string;
  apiKeys: Record<string, string>;
}

class Agent {
  constructor(private config: AgentConfig) {}

  // Cada agente tem suas proprias credenciais
  private getApiKey(service: string): string {
    return this.config.apiKeys[service]
      || env[`${this.config.id.toUpperCase()}_${service}_KEY`]
      || env[`${service}_KEY`]; // fallback global
  }

  // Memoria isolada por namespace
  async getMemories(userId: string): Promise<Memory[]> {
    return db.query(
      'SELECT * FROM agent_memories WHERE agent_id = ? AND user_id = ?',
      [this.config.id, userId]
    );
  }

  async saveMemory(userId: string, content: string): Promise<void> {
    await db.insert('agent_memories', {
      agent_id: this.config.id,
      user_id: userId,
      content,
      created_at: new Date(),
    });
  }

  // Apenas as tools autorizadas
  getAvailableTools(): Tool[] {
    return this.config.tools; // Nao tem acesso a tools de outros agentes
  }
}

// Configuracao dos agentes com isolamento
const researchAgent = new Agent({
  id: 'research',
  name: 'Agente de Pesquisa',
  provider: openrouter, // Provider mais barato para pesquisa
  tools: [webSearch, readUrl, summarize],
  memoryNamespace: 'research',
  apiKeys: { SERPER: env.RESEARCH_SERPER_KEY },
});

const commsAgent = new Agent({
  id: 'comms',
  name: 'Agente de Comunicacao',
  provider: ollama, // Local, privado
  tools: [sendEmail, readEmail, formatMessage],
  memoryNamespace: 'comms',
  apiKeys: { GMAIL: env.COMMS_GMAIL_TOKEN },
});

// context/manager.ts - Context Window Manager
import { encode } from 'gpt-tokenizer'; // Token counting

interface ContextManagerConfig {
  maxTokens: number;       // Limite do modelo (ex: 128000)
  compactThreshold: number; // Quando compactar (ex: 0.6 = 60%)
  strategy: 'sliding' | 'summarize' | 'rag' | 'reset';
  keepLastN: number;       // Mensagens recentes que nunca sao removidas
}

class ContextManager {
  constructor(private config: ContextManagerConfig) {}

  async manage(messages: Message[]): Promise<Message[]> {
    const totalTokens = this.countTokens(messages);
    const threshold = this.config.maxTokens * this.config.compactThreshold;

    if (totalTokens < threshold) return messages; // Dentro do budget

    switch (this.config.strategy) {
      case 'sliding':
        return messages.slice(-this.config.keepLastN);

      case 'summarize':
        return this.compactWithSummary(messages);

      case 'rag':
        return this.retrieveRelevant(messages);

      case 'reset':
        return [messages[0], ...messages.slice(-2)]; // System + last exchange
    }
  }

  private async compactWithSummary(messages: Message[]): Promise<Message[]> {
    const system = messages[0]; // Preservar system prompt
    const recent = messages.slice(-this.config.keepLastN);
    const old = messages.slice(1, -this.config.keepLastN);

    // Pedir ao modelo para resumir as mensagens antigas
    const summary = await this.summarize(old);

    return [
      system,
      { role: 'system', content: `[Resumo da conversa anterior]\n${summary}` },
      ...recent,
    ];
  }

  private countTokens(messages: Message[]): number {
    return messages.reduce((sum, m) => sum + encode(m.content).length, 0);
  }
}

// docs/context-design.md - Template do documento de design

# Design de Contexto - [Nome do SaaS]

## 1. Contexto Global
- Identidade: [Quem e a plataforma]
- Regras universais: [Lista de regras]
- Formato padrao: [Como respostas devem ser formatadas]

## 2. Agentes e seus Contextos
| Agente | Provider | Token Budget | Tools | Estrategia |
|--------|----------|-------------|-------|------------|
| research | openrouter | 50K | web_search, summarize | RAG |
| comms | ollama | 8K | send_email, read_email | sliding |
| coding | claude | 100K | file_read, file_write | summarize |
| classifier | ollama | 4K | - | reset |

## 3. Regras de Compartilhamento
| Dado | Leitura | Escrita | Storage |
|------|---------|---------|---------|
| user_profile | todos | auth service | DB |
| user_preferences | todos | qualquer agente | DB + cache |
| conversation_history | agente da sessao | agente da sessao | DB |
| agent_memories | agente dono | agente dono | DB (namespaced) |

## 4. Compactacao
- Threshold global: 60% da context window
- Modelo para sumarizacao: [modelo barato]
- Frequencia de compactacao: a cada N turnos ou ao atingir threshold
- Dados que nunca sao compactados: system prompt, user profile