import os
from dotenv import load_dotenv
from google.adk.agents import Agent

load_dotenv()

MODEL = os.getenv("ADK_MODEL", "gemini-3.8-flash")

# Definir el agente raíz (root_agent)
root_agent = Agent(
    name="quantum_support_agent",
    model=MODEL,
    description="Asistente de soporte técnico e infraestructura de QuantumRoast.",
    instruction="""
    Eres el asistente técnico de operaciones de QuantumRoast.
    Tu misión es brindar diagnósticos claros, directos y estructurados a los ingenieros
    de guardia cuando reporten anomalías en los sistemas.
    """,
)

import os
from dotenv import load_dotenv
from google.adk.agents import Agent

load_dotenv()

MODEL = os.getenv("ADK_MODEL", "gemini-3.8-flash")


# Función determinista en Python con type hints y docstring descriptivo
def calcular_severidad_incidente(usuarios_afectados: int, afecta_facturacion: bool, latencia_ms: float) -> dict:
    """Calcula de forma estricta la severidad técnica de un incidente y el tiempo máximo de SLA.

    Args:
        usuarios_afectados: Cantidad estimada de usuarios con errores.
        afecta_facturacion: Verdadero si la pasarela de pagos o cobros está degradada.
        latencia_ms: Latencia promedio actual en milisegundos.
    """
    if afecta_facturacion or usuarios_afectados > 2000 or latencia_ms > 2500.0:
        return {"severidad": "P0 - Bloqueante", "sla_minutos": 15, "escalar_inmediato": True}
    elif usuarios_afectados > 300 or latencia_ms > 800.0:
        return {"severidad": "P1 - Crítico", "sla_minutos": 60, "escalar_inmediato": True}
    elif usuarios_afectados > 30:
        return {"severidad": "P2 - Mayor", "sla_minutos": 240, "escalar_inmediato": False}
    return {"severidad": "P3 - Menor", "sla_minutos": 1440, "escalar_inmediato": False}


root_agent = Agent(
    name="triage_agent",
    model=MODEL,
    description="Agente clasificador y regulador de severidad de incidentes de software.",
    instruction="""
    Siempre que un usuario describa métricas o impacto de un problema, DEBES ejecutar
    la herramienta calcular_severidad_incidente antes de emitir tu veredicto o plan de acción.
    """,
    tools=[calcular_severidad_incidente],
)

import os
from dotenv import load_dotenv
from google.adk.agents import Agent
from google.adk.tools import google_search

load_dotenv()

MODEL = os.getenv("ADK_MODEL", "gemini-3.8-flash")

root_agent = Agent(
    name="research_agent",
    model=MODEL,
    description="Agente investigador de incidentes y estado de servicios en tiempo real.",
    instruction="""
    Eres un analista de incidentes externo. Usa la herramienta de búsqueda en Google
    para verificar incidentes públicos, caídas de proveedores cloud o reportes de estado
    técnico en tiempo real. Siempre referencia las fuentes encontradas.
    """,
    tools=[google_search],
)

import sqlite3
from pathlib import Path

# Ruta absoluta junto a este archivo, para que funcione desde cualquier directorio
DB_PATH = Path(__file__).resolve().parent / "incidentes.db"


def inicializar_base_datos():
    conexion = sqlite3.connect(DB_PATH)
    cursor = conexion.cursor()
    cursor.execute("""
        CREATE TABLE IF NOT EXISTS historial_incidentes (
            id TEXT PRIMARY KEY,
            servicio TEXT,
            estado TEXT,
            solucion_aplicada TEXT
        )
    """)
    cursor.execute("DELETE FROM historial_incidentes")
    cursor.executemany("""
        INSERT INTO historial_incidentes VALUES (?, ?, ?, ?)
    """, [
        ("INC-801", "pagos-api", "RESUELTO", "Se incrementó el tamaño del pool de conexiones en Cloud SQL"),
        ("INC-802", "usuarios-auth", "INVESTIGANDO", "Se reiniciaron réplicas en Cloud Run tras fuga de memoria en Node.js"),
        ("INC-803", "catalogo-productos", "ABIERTO", "Latencia elevada causada por indexación pendiente en la tabla de productos"),
    ])
    conexion.commit()
    conexion.close()


if __name__ == "__main__":
    inicializar_base_datos()
    print(f"Base de datos de incidentes inicializada con éxito en {DB_PATH}")

import os
import sqlite3
from pathlib import Path
from dotenv import load_dotenv
from google.adk.agents import Agent

load_dotenv()

MODEL = os.getenv("ADK_MODEL", "gemini-3.8-flash")
DB_PATH = Path(__file__).resolve().parent / "incidentes.db"


def consultar_historial_servicio(nombre_servicio: str) -> list[dict]:
    """Consulta en la base de datos interna los incidentes registrados de un microservicio específico.

    Args:
        nombre_servicio: El nombre o identificador del microservicio a buscar (ej. 'pagos-api', 'usuarios-auth').
    """
    conexion = sqlite3.connect(DB_PATH)
    cursor = conexion.cursor()
    cursor.execute(
        "SELECT id, servicio, estado, solucion_aplicada FROM historial_incidentes WHERE servicio LIKE ?",
        (f"%{nombre_servicio}%",),
    )
    filas = cursor.fetchall()
    conexion.close()
    return [{"id": f[0], "servicio": f[1], "estado": f[2], "solucion": f[3]} for f in filas]


root_agent = Agent(
    name="db_support_agent",
    model=MODEL,
    description="Agente con acceso al registro histórico de incidentes en base de datos.",
    instruction="""
    Cuando el operador mencione un problema en un microservicio, consulta primero
    la base de datos interna con consultar_historial_servicio para ver soluciones anteriores
    antes de sugerir nuevas medidas.
    """,
    tools=[consultar_historial_servicio],
)

"""Servidor MCP de solo lectura sobre la base de datos de incidentes."""
import sqlite3
from pathlib import Path

try:
    from mcp.server.mcpserver import MCPServer  # mcp >= 2.0
except ImportError:
    from mcp.server.fastmcp import FastMCP as MCPServer  # mcp 1.x

DB_PATH = Path(__file__).resolve().parent.parent / "paso4_mcp_database" / "incidentes.db"

servidor = MCPServer("incidentes-quantumroast")


def _consultar(sql: str, parametros: tuple = ()) -> list[dict]:
    # Conexión en modo solo lectura
    conexion = sqlite3.connect(f"file:{DB_PATH}?mode=ro", uri=True)
    conexion.row_factory = sqlite3.Row
    filas = [dict(f) for f in conexion.execute(sql, parametros).fetchall()]
    conexion.close()
    return filas


@servidor.tool()
def listar_servicios() -> list[str]:
    """Lista los microservicios que tienen incidentes registrados."""
    return [f["servicio"] for f in _consultar("SELECT DISTINCT servicio FROM historial_incidentes ORDER BY servicio")]


@servidor.tool()
def buscar_incidentes(servicio: str) -> list[dict]:
    """Busca los incidentes de un microservicio (coincidencia parcial del nombre).

    Args:
        servicio: Nombre o fragmento del nombre del microservicio, ej. 'pagos'.
    """
    return _consultar("SELECT * FROM historial_incidentes WHERE servicio LIKE ?", (f"%{servicio}%",))


@servidor.tool()
def incidentes_por_estado(estado: str) -> list[dict]:
    """Devuelve los incidentes con un estado dado.

    Args:
        estado: Uno de 'ABIERTO', 'INVESTIGANDO' o 'RESUELTO'.
    """
    return _consultar("SELECT * FROM historial_incidentes WHERE estado = ?", (estado.upper(),))


if __name__ == "__main__":
    servidor.run()  # transporte stdio por defecto

import os
import sys
from pathlib import Path
from dotenv import load_dotenv
from google.adk.agents import Agent
from google.adk.tools.mcp_tool import McpToolset, StdioConnectionParams
from mcp import StdioServerParameters

load_dotenv()

MODEL = os.getenv("ADK_MODEL", "gemini-3.8-flash")
SERVIDOR_MCP = Path(__file__).resolve().parent / "mcp_server.py"

# ADK arranca el servidor MCP como subproceso y se comunica por stdio
incidentes_mcp = McpToolset(
    connection_params=StdioConnectionParams(
        server_params=StdioServerParameters(command=sys.executable, args=[str(SERVIDOR_MCP)]),
        timeout=30,
    ),
)

root_agent = Agent(
    name="mcp_db_agent",
    model=MODEL,
    description="Agente que consulta el historial de incidentes a través de un servidor MCP.",
    instruction="""
    Tienes acceso de solo lectura al historial de incidentes mediante herramientas MCP.
    Úsalas para responder con datos reales y termina con una recomendación breve.
    """,
    tools=[incidentes_mcp],
)

import os
from dotenv import load_dotenv
from google.adk.agents import Agent
from google.adk.tools import google_search
from google.adk.tools.agent_tool import AgentTool

load_dotenv()

MODEL = os.getenv("ADK_MODEL", "gemini-3.8-flash")


# Especialista 1: cálculo y verificación de SLAs
def verificar_sla_guardia(nivel_severidad: str) -> str:
    """Retorna la política de tiempo de respuesta acordada para la guardia.

    Args:
        nivel_severidad: Nivel de severidad del incidente: 'P0', 'P1', 'P2' o 'P3'.
    """
    reglas = {
        "P0": "15 minutos (notificación sonora inmediata a jefatura y equipo on-call)",
        "P1": "45 minutos (notificación a canal de Slack de operaciones)",
        "P2": "4 horas en horario laboral",
    }
    return reglas.get(nivel_severidad.upper(), "24 horas hábiles")


agente_sla = Agent(
    name="especialista_sla",
    model=MODEL,
    description="Especialista en clasificar tiempos de respuesta y escalamiento de guardias.",
    instruction="Analiza la urgencia, determina la severidad (P0-P3) y define el protocolo de escalamiento estricto usando verificar_sla_guardia.",
    tools=[verificar_sla_guardia],
)

# Especialista 2: monitoreo de la web y proveedores externos
agente_investigador = Agent(
    name="especialista_red",
    model=MODEL,
    description="Especialista en investigar caídas de proveedores de nube o telecomunicaciones.",
    instruction="Usa la búsqueda en Google para corroborar caídas masivas en proveedores cloud o CDN. Cita tus fuentes.",
    tools=[google_search],
)

# Agente orquestador raíz
root_agent = Agent(
    name="comandante_incidentes",
    model=MODEL,
    description="Coordinador en jefe para resolución de incidentes técnicos en QuantumRoast.",
    instruction="""
    Eres el Comandante de Incidentes.
    Tienes a tu disposición a dos especialistas:
    1. 'especialista_sla': Para determinar ventanas de respuesta y alertas on-call.
    2. 'especialista_red': Para verificar si el fallo proviene de proveedores de nube externos.

    Recibe el reporte del ingeniero, consulta a AMBOS especialistas y sintetiza un plan de acción
    ejecutivo, claro y priorizado.
    """,
    tools=[AgentTool(agent=agente_sla), AgentTool(agent=agente_investigador)],
)