def montar_worker():
    """
    Monta o worker completo em memória a partir dos blocos do banco de dados.
    Retorna um dicionário com todas as funções e configurações carregadas.
    """
    global _CODIGO_MONTADO, _ULTIMA_ATUALIZACAO, _BLOCO_FUNCTIONS

    agora = datetime.now()
    if _ULTIMA_ATUALIZACAO and (agora - _ULTIMA_ATUALIZACAO).total_seconds() < 60:
        return _BLOCO_FUNCTIONS

    log("🔄 Montando worker dinâmico a partir dos blocos do banco...")

    # Carregar dados do banco
    blocos = carregar_blocos_do_banco()
    apis = carregar_apis_radiusnet()
    configs = carregar_configuracoes()

    # Construir código Python completo
    codigo_completo = []
    codigo_completo.append("# Código gerado dinamicamente em " + agora.strftime("%Y-%m-%d %H:%M:%S"))
    codigo_completo.append("import json, requests, re, time")
    codigo_completo.append("from datetime import datetime")
    codigo_completo.append("")

    # Adicionar configurações como variáveis globais
    codigo_completo.append("# Configurações do banco")
    for chave, valor in configs.items():
        if chave.startswith('timeout_'):
            codigo_completo.append(f"TIMEOUT_{chave.upper()} = {valor}")
        elif chave in ['saudacao_inicial', 'mensagem_encaminhamento_humano', 'mensagem_despedida_padrao',
                       'mensagem_timeout_alerta', 'mensagem_timeout_encerramento']:
            codigo_completo.append(f"{chave.upper()} = '''{valor}'''")
    codigo_completo.append("")

    # Adicionar constantes de APIs
    codigo_completo.append("# Constantes de API")
    codigo_completo.append(f"RADIUSNET_BASE_URL = '{RADIUSNET_BASE_URL}'")
    codigo_completo.append(f"RADIUSNET_TOKEN = '{RADIUSNET_TOKEN}'")
    codigo_completo.append("")

    # Adicionar mapeamento de APIs
    codigo_completo.append("# Mapeamento de APIs RadiusNet")
    codigo_completo.append("APIS_RADIUSNET = " + json.dumps(apis, indent=4, ensure_ascii=False))
    codigo_completo.append("")

    # Adicionar função genérica de chamada de API (COM LOGS DETALHADOS)
    codigo_completo.append('''
def chamar_api_radiusnet(nome_api: str, **kwargs) -> dict:
    """Função genérica para chamar qualquer API RadiusNet cadastrada."""
    if nome_api not in APIS_RADIUSNET:
        return {"success": False, "error": f"API '{nome_api}' não encontrada"}

    api_info = APIS_RADIUSNET[nome_api]
    url = RADIUSNET_BASE_URL + api_info['endpoint']

    # Substituir placeholders na URL
    for param, valor in kwargs.items():
        url = url.replace(f"{{{param}}}", str(valor))

    headers = {"RTOKEN": RADIUSNET_TOKEN}
    headers.update(api_info.get('headers', {}))

    # Preparar corpo para POST/PUT (apenas parâmetros que não são placeholders)
    body = {k: v for k, v in kwargs.items() if f"{{{k}}}" not in api_info['endpoint']}

    # LOG DA REQUISIÇÃO
    log(f"[API] Chamando {nome_api} | Método: {api_info['metodo']} | URL: {url}", "INFO")
    log(f"[API] Headers: {headers}", "DEBUG")
    if api_info['metodo'] in ['POST', 'PUT']:
        log(f"[API] Corpo (form-data): {body}", "INFO")
    else:
        log(f"[API] Parâmetros na URL: {kwargs}", "INFO")

    try:
        if api_info['metodo'] == 'GET':
            resp = requests.get(url, headers=headers, timeout=10)
        elif api_info['metodo'] == 'POST':
            # CORREÇÃO: usar data=body para enviar como form-data (multipart/form-data)
            resp = requests.post(url, data=body, headers=headers, timeout=10)
        elif api_info['metodo'] == 'PUT':
            # CORREÇÃO: usar data=body para enviar como form-data
            resp = requests.put(url, data=body, headers=headers, timeout=10)
        else:
            return {"success": False, "error": f"Método {api_info['metodo']} não suportado"}

        # LOG DA RESPOSTA
        log(f"[API] Resposta status: {resp.status_code}", "INFO")
        log(f"[API] Resposta body (primeiros 500): {resp.text[:500]}", "INFO")

        if resp.status_code == 200:
            data = resp.json()
            if api_info['tipo_resposta'] == 'rows':
                return {"success": True, "data": data.get("rows", [])}
            elif api_info['tipo_resposta'] == 'raw':
                return {"success": True, "data": data}
            else:
                return {"success": True, "data": data}
        else:
            return {"success": False, "error": f"HTTP {resp.status_code}", "details": resp.text}
    except Exception as e:
        log(f"[API] Exceção: {str(e)}", "ERROR")
        return {"success": False, "error": str(e)}
''')
    codigo_completo.append("")

    # Adicionar funções de ferramentas (tools) - geradas a partir das APIs
    codigo_completo.append("# Ferramentas (Tools) para IA")
    for nome_api in apis.keys():
        nome_funcao = nome_api.replace('-', '_').lower()
        codigo_completo.append(f'''
def tool_{nome_funcao}(**kwargs) -> dict:
    """Wrapper para a API {nome_api}."""
    return chamar_api_radiusnet("{nome_api}", **kwargs)
''')
    codigo_completo.append("")

    # Adicionar definição de TOOLS para DeepSeek
    codigo_completo.append("# Definição de TOOLS para DeepSeek")
    codigo_completo.append("TOOLS = [")
    for nome_api, info in apis.items():
        nome_funcao = nome_api.replace('-', '_').lower()
        parametros_schema = info.get('parametros', {})
        codigo_completo.append(f'''    {{
        "type": "function",
        "function": {{
            "name": "tool_{nome_funcao}",
            "description": "{info.get('descricao', nome_api)}",
            "parameters": {json.dumps(parametros_schema)}
        }}
    }},''')
    codigo_completo.append("]")
    codigo_completo.append("")

    # Adicionar blocos de código personalizados (etapas, fluxos, regras)
    codigo_completo.append("# Blocos de código personalizados")
    for bloco in blocos:
        if bloco['tipo'] == 'nucleo':
            continue
        codigo_completo.append(f"# Bloco: {bloco['nome']} (Tipo: {bloco['tipo']})")
        codigo_completo.append(bloco['conteudo'])
        codigo_completo.append("")

    # Juntar todo o código
    codigo_str = '\\n'.join(codigo_completo)

    # Executar o código para carregar as funções no namespace
    namespace = {}
    exec(codigo_str, namespace)

    _BLOCO_FUNCTIONS = namespace
    _ULTIMA_ATUALIZACAO = agora
    _CODIGO_MONTADO = codigo_str

    log(f"✅ Worker montado com sucesso. {len(namespace)} funções carregadas.")

    # Salvar código montado em arquivo para debug (opcional)
    with open('/var/www/html/worker_montado_debug.py', 'w', encoding='utf-8') as f:
        f.write(codigo_str)

    return namespace