sienge-ecbiesek-mcp 1.2.2__py3-none-any.whl → 1.3.0__py3-none-any.whl

sienge_mcp/server.py

@@ -2,27 +2,37 @@
 """
 SIENGE MCP COMPLETO - FastMCP com Autenticação Flexível
 Suporta Bearer Token e Basic Auth
-CORREÇÕES IMPLEMENTADAS:
-1. Separação entre camada MCP e camada de serviços
-2. Alias compatíveis com checklist
-3. Normalização de parâmetros (camelCase + arrays)
-4. Bulk-data assíncrono com polling
-5. Observabilidade mínima (X-Request-ID, cache, logs)
-6. Ajustes de compatibilidade pontuais
 """
 
 from fastmcp import FastMCP
 import httpx
-from typing import Dict, List, Optional, Any, Union
+from typing import Dict, List, Optional, Any
 import os
 from dotenv import load_dotenv
-from datetime import datetime, timedelta
+from datetime import datetime
+import time
 import uuid
 import asyncio
-import json
-import time
-import logging
-from functools import wraps
+
+# logger
+from .utils.logger import get_logger
+logger = get_logger()
+
+# Optional: prefer tenacity for robust retries; linter will warn if not installed but code falls back
+try:
+    from tenacity import AsyncRetrying, wait_exponential, stop_after_attempt, retry_if_exception_type  # type: ignore
+    TENACITY_AVAILABLE = True
+except Exception:
+    TENACITY_AVAILABLE = False
+
+# Supabase client (optional)
+try:
+    from supabase import create_client, Client
+    SUPABASE_AVAILABLE = True
+except Exception:
+    SUPABASE_AVAILABLE = False
+    create_client = None
+    Client = None
 
 # Carrega as variáveis de ambiente
 load_dotenv()
@@ -37,273 +47,104 @@ SIENGE_PASSWORD = os.getenv("SIENGE_PASSWORD", "")
 SIENGE_API_KEY = os.getenv("SIENGE_API_KEY", "")
 REQUEST_TIMEOUT = int(os.getenv("REQUEST_TIMEOUT", "30"))
 
-# Cache simples em memória
-_cache = {}
-CACHE_TTL = 300  # 5 minutos
-
-# Configurar logging estruturado
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger("sienge-mcp")
+# Configurações do Supabase
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_SERVICE_ROLE_KEY = os.getenv("SUPABASE_SERVICE_ROLE_KEY")
+SUPABASE_SCHEMA = "sienge_data"  # Schema fixo: sienge_data
 
 
 class SiengeAPIError(Exception):
     """Exceção customizada para erros da API do Sienge"""
-    pass
-
-
-# ============ HELPERS DE NORMALIZAÇÃO E OBSERVABILIDADE ============
-
-def _camel(s: str) -> str:
-    """Converte snake_case para camelCase"""
-    if '_' not in s:
-        return s
-    parts = s.split('_')
-    return parts[0] + ''.join(x.capitalize() for x in parts[1:])
-
-
-def to_query(params: dict) -> dict:
-    """
-    Converte parâmetros para query string normalizada:
-    - snake_case → camelCase
-    - listas/tuplas → CSV string
-    - booleanos → 'true'/'false' (minúsculo)
-    - remove valores None
-    """
-    if not params:
-        return {}
-    
-    out = {}
-    for k, v in params.items():
-        if v is None:
-            continue
-        key = _camel(k)
-        if isinstance(v, (list, tuple)):
-            out[key] = ','.join(map(str, v))
-        elif isinstance(v, bool):
-            out[key] = 'true' if v else 'false'
-        else:
-            out[key] = v
-    return out
-
-
-def to_camel_json(obj: Any) -> Any:
-    """
-    Normaliza payload JSON recursivamente:
-    - snake_case → camelCase nas chaves
-    - remove valores None
-    - mantém estrutura de listas e objetos aninhados
-    """
-    if isinstance(obj, dict):
-        return {_camel(k): to_camel_json(v) for k, v in obj.items() if v is not None}
-    elif isinstance(obj, list):
-        return [to_camel_json(x) for x in obj]
-    else:
-        return obj
-
-
-def _normalize_url(base_url: str, subdomain: str) -> str:
-    """Normaliza URL evitando //public/api quando subdomain está vazio"""
-    if not subdomain or subdomain.strip() == "":
-        return f"{base_url.rstrip('/')}/public/api"
-    return f"{base_url.rstrip('/')}/{subdomain.strip()}/public/api"
-
-
-def _parse_numeric_value(value: Any) -> float:
-    """Sanitiza valores numéricos, lidando com vírgulas decimais"""
-    if value is None:
-        return 0.0
-    
-    if isinstance(value, (int, float)):
-        return float(value)
-    
-    # Se for string, tentar converter
-    str_value = str(value).strip()
-    if not str_value:
-        return 0.0
-    
-    # Trocar vírgula por ponto decimal
-    str_value = str_value.replace(',', '.')
-    
-    try:
-        return float(str_value)
-    except (ValueError, TypeError):
-        logger.warning(f"Não foi possível converter '{value}' para número")
-        return 0.0
-
-
-def _get_cache_key(endpoint: str, params: dict = None) -> str:
-    """Gera chave de cache baseada no endpoint e parâmetros"""
-    cache_params = json.dumps(params or {}, sort_keys=True)
-    return f"{endpoint}:{hash(cache_params)}"
-
 
-def _set_cache(key: str, data: Any) -> None:
-    """Armazena dados no cache com TTL"""
-    _cache[key] = {
-        "data": data,
-        "timestamp": time.time(),
-        "ttl": CACHE_TTL
-    }
-
-
-def _get_cache(key: str) -> Optional[Dict]:
-    """Recupera dados do cache se ainda válidos - CORRIGIDO: mantém shape original"""
-    if key not in _cache:
-        return None
-    
-    cached = _cache[key]
-    if time.time() - cached["timestamp"] > cached["ttl"]:
-        del _cache[key]  # Remove cache expirado
-        return None
-    
-    # cached["data"] já é o "result" completo salvo em _set_cache
-    result = dict(cached["data"])  # cópia rasa
-    result["cache"] = {
-        "hit": True,
-        "ttl_s": cached["ttl"] - (time.time() - cached["timestamp"])
-    }
-    return result
-
-
-def _log_request(method: str, endpoint: str, status_code: int, latency: float, request_id: str) -> None:
-    """Log estruturado das requisições"""
-    logger.info(
-        f"HTTP {method} {endpoint} - Status: {status_code} - "
-        f"Latency: {latency:.3f}s - RequestID: {request_id}"
-    )
-
-
-def _extract_items_and_total(resp_data: Any) -> tuple:
-    """
-    Extrai items e total count de resposta padronizada da API Sienge
-    Retorna: (items_list, total_count)
-    """
-    items = resp_data.get("results", []) if isinstance(resp_data, dict) else (resp_data or [])
-    meta = resp_data.get("resultSetMetadata", {}) if isinstance(resp_data, dict) else {}
-    total = meta.get("count", len(items))
-    return items, total
+    pass
 
 
 async def make_sienge_request(
-    method: str, endpoint: str, params: Optional[Dict] = None, json_data: Optional[Dict] = None, use_cache: bool = True
+    method: str, endpoint: str, params: Optional[Dict] = None, json_data: Optional[Dict] = None
 ) -> Dict:
     """
     Função auxiliar para fazer requisições à API do Sienge (v1)
     Suporta tanto Bearer Token quanto Basic Auth
-    MELHORADO: Observabilidade, cache, normalização de parâmetros
     """
-    start_time = time.time()
-    req_id = str(uuid.uuid4())
-    
-    try:
-        # Normalizar parâmetros
-        normalized_params = to_query(params) if params else None
-        
-        # Verificar cache para operações GET
-        cache_key = None
-        if method.upper() == "GET" and use_cache and endpoint in ["/customer-types", "/creditors", "/customers"]:
-            cache_key = _get_cache_key(endpoint, normalized_params)
-            cached_result = _get_cache(cache_key)
-            if cached_result:
-                cached_result["request_id"] = req_id
-                return cached_result
-        
-        async with httpx.AsyncClient(timeout=REQUEST_TIMEOUT) as client:
-            headers = {
-                "Content-Type": "application/json", 
-                "Accept": "application/json",
-                "X-Request-ID": req_id
-            }
+    # Attach a request id and measure latency
+    request_id = str(uuid.uuid4())
+    start_ts = time.time()
 
-            # Configurar autenticação e URL (corrigindo URLs duplas)
-            auth = None
-            base_normalized = _normalize_url(SIENGE_BASE_URL, SIENGE_SUBDOMAIN)
+    headers = {"Content-Type": "application/json", "Accept": "application/json", "X-Request-Id": request_id}
 
-            if SIENGE_API_KEY and SIENGE_API_KEY != "sua_api_key_aqui":
-                headers["Authorization"] = f"Bearer {SIENGE_API_KEY}"
-                url = f"{base_normalized}/v1{endpoint}"
-            elif SIENGE_USERNAME and SIENGE_PASSWORD:
-                auth = httpx.BasicAuth(SIENGE_USERNAME, SIENGE_PASSWORD)
-                url = f"{base_normalized}/v1{endpoint}"
-            else:
-                return {
-                    "success": False,
-                    "error": "No Authentication",
-                    "message": "Configure SIENGE_API_KEY ou SIENGE_USERNAME/PASSWORD no .env",
-                    "request_id": req_id
-                }
+    # Configurar autenticação e URL
+    auth = None
 
-            response = await client.request(
-                method=method, 
-                url=url, 
-                headers=headers, 
-                params=normalized_params, 
-                json=json_data, 
-                auth=auth
-            )
-            
-            latency = time.time() - start_time
-            _log_request(method, endpoint, response.status_code, latency, req_id)
+    if SIENGE_API_KEY and SIENGE_API_KEY != "sua_api_key_aqui":
+        headers["Authorization"] = f"Bearer {SIENGE_API_KEY}"
+        url = f"{SIENGE_BASE_URL}/{SIENGE_SUBDOMAIN}/public/api/v1{endpoint}"
+    elif SIENGE_USERNAME and SIENGE_PASSWORD:
+        auth = httpx.BasicAuth(SIENGE_USERNAME, SIENGE_PASSWORD)
+        url = f"{SIENGE_BASE_URL}/{SIENGE_SUBDOMAIN}/public/api/v1{endpoint}"
+    else:
+        return {
+            "success": False,
+            "error": "No Authentication",
+            "message": "Configure SIENGE_API_KEY ou SIENGE_USERNAME/PASSWORD no .env",
+            "request_id": request_id,
+        }
 
-            if response.status_code in [200, 201]:
+    async def _do_request(client: httpx.AsyncClient):
+        return await client.request(method=method, url=url, headers=headers, params=params, json=json_data, auth=auth)
+
+    try:
+        max_attempts = 5
+        attempts = 0
+        async with httpx.AsyncClient(timeout=REQUEST_TIMEOUT) as client:
+            while True:
+                attempts += 1
                 try:
-                    data = response.json()
-                    result = {
-                        "success": True, 
-                        "data": data, 
-                        "status_code": response.status_code,
-                        "request_id": req_id,
-                        "latency_ms": round(latency * 1000, 2)
-                    }
-                    
-                    # Armazenar no cache se aplicável
-                    if cache_key and method.upper() == "GET":
-                        _set_cache(cache_key, result)
-                        result["cache"] = {"hit": False, "ttl_s": CACHE_TTL}
-                    
-                    return result
-                    
-                except Exception:
+                    response = await client.request(method=method, url=url, headers=headers, params=params, json=json_data, auth=auth)
+                except (httpx.RequestError, httpx.TimeoutException) as exc:
+                    logger.warning(f"Request error to {url}: {exc} (attempt {attempts}/{max_attempts})")
+                    if attempts >= max_attempts:
+                        raise
+                    await asyncio.sleep(min(2 ** attempts, 60))
+                    continue
+
+                # Handle rate limit explicitly
+                if response.status_code == 429:
+                    retry_after = response.headers.get("Retry-After")
+                    try:
+                        wait_seconds = int(retry_after) if retry_after is not None else min(2 ** attempts, 60)
+                    except Exception:
+                        wait_seconds = min(2 ** attempts, 60)
+                    logger.warning(f"HTTP 429 from {url}, retrying after {wait_seconds}s (attempt {attempts}/{max_attempts})")
+                    if attempts >= max_attempts:
+                        latency_ms = int((time.time() - start_ts) * 1000)
+                        return {"success": False, "error": "HTTP 429", "message": response.text, "status_code": 429, "latency_ms": latency_ms, "request_id": request_id}
+                    await asyncio.sleep(wait_seconds)
+                    continue
+
+                latency_ms = int((time.time() - start_ts) * 1000)
+
+                if response.status_code in [200, 201]:
+                    try:
+                        return {"success": True, "data": response.json(), "status_code": response.status_code, "latency_ms": latency_ms, "request_id": request_id}
+                    except BaseException:
+                        return {"success": True, "data": {"message": "Success"}, "status_code": response.status_code, "latency_ms": latency_ms, "request_id": request_id}
+                else:
+                    logger.warning(f"HTTP {response.status_code} from {url}: {response.text}")
                     return {
-                        "success": True, 
-                        "data": {"message": "Success"}, 
+                        "success": False,
+                        "error": f"HTTP {response.status_code}",
+                        "message": response.text,
                         "status_code": response.status_code,
-                        "request_id": req_id,
-                        "latency_ms": round(latency * 1000, 2)
+                        "latency_ms": latency_ms,
+                        "request_id": request_id,
                     }
-            else:
-                return {
-                    "success": False,
-                    "error": f"HTTP {response.status_code}",
-                    "message": response.text,
-                    "status_code": response.status_code,
-                    "request_id": req_id,
-                    "latency_ms": round(latency * 1000, 2)
-                }
 
     except httpx.TimeoutException:
-        latency = time.time() - start_time
-        _log_request(method, endpoint, 408, latency, req_id)
-        return {
-            "success": False, 
-            "error": "Timeout", 
-            "message": f"A requisição excedeu o tempo limite de {REQUEST_TIMEOUT}s",
-            "request_id": req_id,
-            "latency_ms": round(latency * 1000, 2)
-        }
+        latency_ms = int((time.time() - start_ts) * 1000)
+        return {"success": False, "error": "Timeout", "message": f"A requisição excedeu o tempo limite de {REQUEST_TIMEOUT}s", "latency_ms": latency_ms, "request_id": request_id}
     except Exception as e:
-        latency = time.time() - start_time
-        _log_request(method, endpoint, 500, latency, req_id)
-        return {
-            "success": False, 
-            "error": str(e), 
-            "message": f"Erro na requisição: {str(e)}",
-            "request_id": req_id,
-            "latency_ms": round(latency * 1000, 2)
-        }
+        latency_ms = int((time.time() - start_ts) * 1000)
+        return {"success": False, "error": str(e), "message": f"Erro na requisição: {str(e)}", "latency_ms": latency_ms, "request_id": request_id}
 
 
 async def make_sienge_bulk_request(
@@ -312,359 +153,94 @@ async def make_sienge_bulk_request(
     """
     Função auxiliar para fazer requisições à API bulk-data do Sienge
     Suporta tanto Bearer Token quanto Basic Auth
-    MELHORADO: Observabilidade e normalização de parâmetros
     """
-    start_time = time.time()
-    req_id = str(uuid.uuid4())
-    
-    try:
-        # Normalizar parâmetros
-        normalized_params = to_query(params) if params else None
-        
-        async with httpx.AsyncClient(timeout=REQUEST_TIMEOUT) as client:
-            headers = {
-                "Content-Type": "application/json", 
-                "Accept": "application/json",
-                "X-Request-ID": req_id
-            }
+    # Similar to make_sienge_request but targeting bulk-data endpoints
+    request_id = str(uuid.uuid4())
+    start_ts = time.time()
 
-            # Configurar autenticação e URL para bulk-data (corrigindo URLs duplas)
-            auth = None
-            base_normalized = _normalize_url(SIENGE_BASE_URL, SIENGE_SUBDOMAIN)
+    headers = {"Content-Type": "application/json", "Accept": "application/json", "X-Request-Id": request_id}
 
-            if SIENGE_API_KEY and SIENGE_API_KEY != "sua_api_key_aqui":
-                headers["Authorization"] = f"Bearer {SIENGE_API_KEY}"
-                url = f"{base_normalized}/bulk-data/v1{endpoint}"
-            elif SIENGE_USERNAME and SIENGE_PASSWORD:
-                auth = httpx.BasicAuth(SIENGE_USERNAME, SIENGE_PASSWORD)
-                url = f"{base_normalized}/bulk-data/v1{endpoint}"
-            else:
-                return {
-                    "success": False,
-                    "error": "No Authentication",
-                    "message": "Configure SIENGE_API_KEY ou SIENGE_USERNAME/PASSWORD no .env",
-                    "request_id": req_id
-                }
+    auth = None
+    if SIENGE_API_KEY and SIENGE_API_KEY != "sua_api_key_aqui":
+        headers["Authorization"] = f"Bearer {SIENGE_API_KEY}"
+        url = f"{SIENGE_BASE_URL}/{SIENGE_SUBDOMAIN}/public/api/bulk-data/v1{endpoint}"
+    elif SIENGE_USERNAME and SIENGE_PASSWORD:
+        auth = httpx.BasicAuth(SIENGE_USERNAME, SIENGE_PASSWORD)
+        url = f"{SIENGE_BASE_URL}/{SIENGE_SUBDOMAIN}/public/api/bulk-data/v1{endpoint}"
+    else:
+        return {
+            "success": False,
+            "error": "No Authentication",
+            "message": "Configure SIENGE_API_KEY ou SIENGE_USERNAME/PASSWORD no .env",
+            "request_id": request_id,
+        }
 
-            response = await client.request(
-                method=method, 
-                url=url, 
-                headers=headers, 
-                params=normalized_params, 
-                json=json_data, 
-                auth=auth
-            )
-            
-            latency = time.time() - start_time
-            _log_request(method, f"bulk-data{endpoint}", response.status_code, latency, req_id)
+    async def _do_request(client: httpx.AsyncClient):
+        return await client.request(method=method, url=url, headers=headers, params=params, json=json_data, auth=auth)
 
-            if response.status_code in [200, 201, 202]:
+    try:
+        max_attempts = 5
+        attempts = 0
+        async with httpx.AsyncClient(timeout=REQUEST_TIMEOUT) as client:
+            while True:
+                attempts += 1
                 try:
+                    response = await client.request(method=method, url=url, headers=headers, params=params, json=json_data, auth=auth)
+                except (httpx.RequestError, httpx.TimeoutException) as exc:
+                    logger.warning(f"Bulk request error to {url}: {exc} (attempt {attempts}/{max_attempts})")
+                    if attempts >= max_attempts:
+                        raise
+                    await asyncio.sleep(min(2 ** attempts, 60))
+                    continue
+
+                if response.status_code == 429:
+                    retry_after = response.headers.get("Retry-After")
+                    try:
+                        wait_seconds = int(retry_after) if retry_after is not None else min(2 ** attempts, 60)
+                    except Exception:
+                        wait_seconds = min(2 ** attempts, 60)
+                    logger.warning(f"HTTP 429 from bulk {url}, retrying after {wait_seconds}s (attempt {attempts}/{max_attempts})")
+                    if attempts >= max_attempts:
+                        latency_ms = int((time.time() - start_ts) * 1000)
+                        return {"success": False, "error": "HTTP 429", "message": response.text, "status_code": 429, "latency_ms": latency_ms, "request_id": request_id}
+                    await asyncio.sleep(wait_seconds)
+                    continue
+
+                latency_ms = int((time.time() - start_ts) * 1000)
+
+                if response.status_code in [200, 201]:
+                    try:
+                        return {"success": True, "data": response.json(), "status_code": response.status_code, "latency_ms": latency_ms, "request_id": request_id}
+                    except BaseException:
+                        return {"success": True, "data": {"message": "Success"}, "status_code": response.status_code, "latency_ms": latency_ms, "request_id": request_id}
+                else:
+                    logger.warning(f"HTTP {response.status_code} from bulk {url}: {response.text}")
                     return {
-                        "success": True, 
-                        "data": response.json(), 
+                        "success": False,
+                        "error": f"HTTP {response.status_code}",
+                        "message": response.text,
                         "status_code": response.status_code,
-                        "request_id": req_id,
-                        "latency_ms": round(latency * 1000, 2)
+                        "latency_ms": latency_ms,
+                        "request_id": request_id,
                     }
-                except Exception:
-                    return {
-                        "success": True, 
-                        "data": {"message": "Success"}, 
-                        "status_code": response.status_code,
-                        "request_id": req_id,
-                        "latency_ms": round(latency * 1000, 2)
-                    }
-            else:
-                return {
-                    "success": False,
-                    "error": f"HTTP {response.status_code}",
-                    "message": response.text,
-                    "status_code": response.status_code,
-                    "request_id": req_id,
-                    "latency_ms": round(latency * 1000, 2)
-                }
 
     except httpx.TimeoutException:
-        latency = time.time() - start_time
-        _log_request(method, f"bulk-data{endpoint}", 408, latency, req_id)
-        return {
-            "success": False, 
-            "error": "Timeout", 
-            "message": f"A requisição excedeu o tempo limite de {REQUEST_TIMEOUT}s",
-            "request_id": req_id,
-            "latency_ms": round(latency * 1000, 2)
-        }
+        latency_ms = int((time.time() - start_ts) * 1000)
+        return {"success": False, "error": "Timeout", "message": f"A requisição excedeu o tempo limite de {REQUEST_TIMEOUT}s", "latency_ms": latency_ms, "request_id": request_id}
     except Exception as e:
-        latency = time.time() - start_time
-        _log_request(method, f"bulk-data{endpoint}", 500, latency, req_id)
-        return {
-            "success": False, 
-            "error": str(e), 
-            "message": f"Erro na requisição bulk-data: {str(e)}",
-            "request_id": req_id,
-            "latency_ms": round(latency * 1000, 2)
-        }
-
-
-async def _fetch_bulk_with_polling(method: str, endpoint: str, params: Optional[Dict] = None, json_data: Optional[Dict] = None) -> Dict:
-    """
-    Faz requisição bulk com polling automático para requests assíncronos (202)
-    """
-    correlation_id = str(uuid.uuid4())
-    
-    # Fazer requisição inicial
-    result = await make_sienge_bulk_request(method, endpoint, params, json_data)
-    
-    # Se não foi 202 ou não tem identifier, retornar resultado direto
-    if result.get("status_code") != 202:
-        return result
-    
-    data = result.get("data", {})
-    if not isinstance(data, dict) or not data.get("identifier"):
-        return result
-    
-    # Processar requisição assíncrona com polling
-    identifier = data["identifier"]
-    request_id = result.get("request_id")
-    
-    logger.info(f"Iniciando polling para bulk request - Identifier: {identifier} - RequestID: {request_id}")
-    
-    max_attempts = 30  # Máximo 5 minutos (30 * 10s)
-    attempt = 0
-    backoff_delay = 2  # Começar com 2 segundos
-    
-    while attempt < max_attempts:
-        attempt += 1
-        await asyncio.sleep(backoff_delay)
-        
-        # Verificar status do processamento
-        status_result = await make_sienge_bulk_request("GET", f"/async/{identifier}")
-        
-        if not status_result["success"]:
-            logger.error(f"Erro ao verificar status do bulk request {identifier}: {status_result.get('error')}")
-            break
-        
-        status_data = status_result.get("data", {})
-        status = status_data.get("status", "unknown")
-        
-        logger.info(f"Polling attempt {attempt} - Status: {status} - Identifier: {identifier}")
-        
-        if status == "completed":
-            # Buscar resultados finais
-            all_chunks = []
-            chunk_count = status_data.get("chunk_count", 1)
-            
-            chunks_downloaded = 0
-            for chunk_num in range(chunk_count):
-                try:
-                    # CORRIGIDO: endpoint aninhado sob /async
-                    chunk_result = await make_sienge_bulk_request("GET", f"/async/{identifier}/result/{chunk_num}")
-                    if chunk_result["success"]:
-                        chunk_data = chunk_result.get("data", {}).get("data", [])
-                        if isinstance(chunk_data, list):
-                            all_chunks.extend(chunk_data)
-                        chunks_downloaded += 1
-                except Exception as e:
-                    logger.warning(f"Erro ao buscar chunk {chunk_num}: {e}")
-            
-            return {
-                "success": True,
-                "data": all_chunks,
-                "async_identifier": identifier,
-                "correlation_id": correlation_id,
-                "chunks_downloaded": chunks_downloaded,
-                "rows_returned": len(all_chunks),
-                "polling_attempts": attempt,
-                "request_id": request_id
-            }
-        
-        elif status == "failed" or status == "error":
-            return {
-                "success": False,
-                "error": "Bulk processing failed",
-                "message": status_data.get("error_message", "Processamento bulk falhou"),
-                "async_identifier": identifier,
-                "correlation_id": correlation_id,
-                "polling_attempts": attempt,
-                "request_id": request_id
-            }
-        
-        # Aumentar delay progressivamente (backoff exponencial limitado)
-        backoff_delay = min(backoff_delay * 1.5, 10)  # Máximo 10 segundos
-    
-    # Timeout do polling
-    return {
-        "success": False,
-        "error": "Polling timeout",
-        "message": f"Processamento bulk não completou em {max_attempts} tentativas",
-        "async_identifier": identifier,
-        "correlation_id": correlation_id,
-        "polling_attempts": attempt,
-        "request_id": request_id
-    }
-
-
-# ============ CAMADA DE SERVIÇOS (FUNÇÕES INTERNAS) ============
-
-async def _svc_get_customer_types() -> Dict:
-    """Serviço interno: buscar tipos de clientes"""
-    return await make_sienge_request("GET", "/customer-types", use_cache=True)
-
-
-async def _svc_get_customers(*, limit: int = 50, offset: int = 0, search: str = None, customer_type_id: str = None) -> Dict:
-    """Serviço interno: buscar clientes"""
-    params = {"limit": min(limit or 50, 200), "offset": offset or 0}
-    if search:
-        params["search"] = search
-    if customer_type_id:
-        params["customer_type_id"] = customer_type_id
-    
-    return await make_sienge_request("GET", "/customers", params=params)
-
-
-async def _svc_get_creditors(*, limit: int = 50, offset: int = 0, search: str = None) -> Dict:
-    """Serviço interno: buscar credores/fornecedores"""
-    params = {"limit": min(limit or 50, 200), "offset": offset or 0}
-    if search:
-        params["search"] = search
-    
-    return await make_sienge_request("GET", "/creditors", params=params)
-
-
-async def _svc_get_creditor_bank_info(*, creditor_id: str) -> Dict:
-    """Serviço interno: informações bancárias de credor"""
-    return await make_sienge_request("GET", f"/creditors/{creditor_id}/bank-informations")
-
-
-async def _svc_get_projects(*, limit: int = 100, offset: int = 0, company_id: int = None, 
-                           enterprise_type: int = None, receivable_register: str = None,
-                           only_buildings_enabled: bool = False) -> Dict:
-    """Serviço interno: buscar empreendimentos/projetos"""
-    params = {"limit": min(limit or 100, 200), "offset": offset or 0}
-    
-    if company_id:
-        params["company_id"] = company_id
-    if enterprise_type:
-        params["type"] = enterprise_type
-    if receivable_register:
-        params["receivable_register"] = receivable_register
-    if only_buildings_enabled:
-        params["only_buildings_enabled_for_integration"] = only_buildings_enabled
-    
-    return await make_sienge_request("GET", "/enterprises", params=params)
-
-
-async def _svc_get_bills(*, start_date: str = None, end_date: str = None, creditor_id: str = None, 
-                        status: str = None, limit: int = 50) -> Dict:
-    """Serviço interno: buscar títulos a pagar"""
-    # Se start_date não fornecido, usar últimos 30 dias
-    if not start_date:
-        start_date = (datetime.now() - timedelta(days=30)).strftime("%Y-%m-%d")
-    
-    # Se end_date não fornecido, usar hoje
-    if not end_date:
-        end_date = datetime.now().strftime("%Y-%m-%d")
-    
-    params = {"start_date": start_date, "end_date": end_date, "limit": min(limit or 50, 200)}
-    
-    if creditor_id:
-        params["creditor_id"] = creditor_id
-    if status:
-        params["status"] = status
-    
-    return await make_sienge_request("GET", "/bills", params=params)
-
-
-async def _svc_get_accounts_receivable(*, start_date: str, end_date: str, selection_type: str = "D",
-                                      company_id: int = None, cost_centers_id: List[int] = None,
-                                      correction_indexer_id: int = None, correction_date: str = None,
-                                      change_start_date: str = None, completed_bills: str = None,
-                                      origins_ids: List[str] = None, bearers_id_in: List[int] = None,
-                                      bearers_id_not_in: List[int] = None) -> Dict:
-    """Serviço interno: buscar contas a receber via bulk-data"""
-    params = {"start_date": start_date, "end_date": end_date, "selection_type": selection_type}
-    
-    if company_id:
-        params["company_id"] = company_id
-    if cost_centers_id:
-        params["cost_centers_id"] = cost_centers_id
-    if correction_indexer_id:
-        params["correction_indexer_id"] = correction_indexer_id
-    if correction_date:
-        params["correction_date"] = correction_date
-    if change_start_date:
-        params["change_start_date"] = change_start_date
-    if completed_bills:
-        params["completed_bills"] = completed_bills
-    if origins_ids:
-        params["origins_ids"] = origins_ids
-    if bearers_id_in:
-        params["bearers_id_in"] = bearers_id_in
-    if bearers_id_not_in:
-        params["bearers_id_not_in"] = bearers_id_not_in
-    
-    return await _fetch_bulk_with_polling("GET", "/income", params=params)
-
-
-async def _svc_get_accounts_receivable_by_bills(*, bills_ids: List[int], correction_indexer_id: int = None,
-                                               correction_date: str = None) -> Dict:
-    """Serviço interno: buscar contas a receber por títulos específicos"""
-    params = {"bills_ids": bills_ids}
-    
-    if correction_indexer_id:
-        params["correction_indexer_id"] = correction_indexer_id
-    if correction_date:
-        params["correction_date"] = correction_date
-    
-    return await _fetch_bulk_with_polling("GET", "/income/by-bills", params=params)
-
-
-async def _svc_get_purchase_orders(*, purchase_order_id: str = None, status: str = None, 
-                                  date_from: str = None, limit: int = 50) -> Dict:
-    """Serviço interno: buscar pedidos de compra"""
-    if purchase_order_id:
-        return await make_sienge_request("GET", f"/purchase-orders/{purchase_order_id}")
-    
-    params = {"limit": min(limit or 50, 200)}
-    if status:
-        params["status"] = status
-    if date_from:
-        params["date_from"] = date_from
-    
-    return await make_sienge_request("GET", "/purchase-orders", params=params)
-
-
-async def _svc_get_purchase_requests(*, purchase_request_id: str = None, limit: int = 50, status: str = None) -> Dict:
-    """Serviço interno: buscar solicitações de compra"""
-    if purchase_request_id:
-        return await make_sienge_request("GET", f"/purchase-requests/{purchase_request_id}")
-    
-    params = {"limit": min(limit or 50, 200)}
-    if status:
-        params["status"] = status
-    
-    return await make_sienge_request("GET", "/purchase-requests", params=params)
-
-
-async def _svc_get_purchase_invoices(*, limit: int = 50, date_from: str = None) -> Dict:
-    """Serviço interno: listar notas fiscais de compra"""
-    params = {"limit": min(limit or 50, 200)}
-    if date_from:
-        params["date_from"] = date_from
-    
-    return await make_sienge_request("GET", "/purchase-invoices", params=params)
+        latency_ms = int((time.time() - start_ts) * 1000)
+        return {"success": False, "error": str(e), "message": f"Erro na requisição bulk-data: {str(e)}", "latency_ms": latency_ms, "request_id": request_id}
 
 
 # ============ CONEXÃO E TESTE ============
 
 
 @mcp.tool
-async def test_sienge_connection(_meta: Optional[Dict] = None) -> Dict:
-    """Testa a conexão com a API do Sienge"""
+async def test_sienge_connection(_meta: Optional[Dict[str, Any]] = None) -> Dict:
+    """Testa a conexão com a API do Sienge e retorna métricas básicas"""
     try:
-        # Usar serviço interno
-        result = await _svc_get_customer_types()
+        # Tentar endpoint mais simples primeiro
+        result = await make_sienge_request("GET", "/customer-types")
 
         if result["success"]:
             auth_method = "Bearer Token" if SIENGE_API_KEY else "Basic Auth"
@@ -674,9 +250,8 @@ async def test_sienge_connection(_meta: Optional[Dict] = None) -> Dict:
                 "api_status": "Online",
                 "auth_method": auth_method,
                 "timestamp": datetime.now().isoformat(),
-                "request_id": result.get("request_id"),
                 "latency_ms": result.get("latency_ms"),
-                "cache": result.get("cache")
+                "request_id": result.get("request_id"),
             }
         else:
             return {
@@ -685,7 +260,8 @@ async def test_sienge_connection(_meta: Optional[Dict] = None) -> Dict:
                 "error": result.get("error"),
                 "details": result.get("message"),
                 "timestamp": datetime.now().isoformat(),
-                "request_id": result.get("request_id")
+                "latency_ms": result.get("latency_ms"),
+                "request_id": result.get("request_id"),
             }
     except Exception as e:
         return {
@@ -701,8 +277,12 @@ async def test_sienge_connection(_meta: Optional[Dict] = None) -> Dict:
 
 @mcp.tool
 async def get_sienge_customers(
-    limit: Optional[int] = 50, offset: Optional[int] = 0, search: Optional[str] = None, customer_type_id: Optional[str] = None,
-    _meta: Optional[Dict] = None
+    limit: Optional[int] = 50,
+    offset: Optional[int] = 0,
+    search: Optional[str] = None,
+    customer_type_id: Optional[str] = None,
+    fetch_all: Optional[bool] = False,
+    max_records: Optional[int] = None,
 ) -> Dict:
     """
     Busca clientes no Sienge com filtros
@@ -713,13 +293,44 @@ async def get_sienge_customers(
         search: Buscar por nome ou documento
         customer_type_id: Filtrar por tipo de cliente
     """
-    # Usar serviço interno
-    result = await _svc_get_customers(
-        limit=limit or 50, 
-        offset=offset or 0, 
-        search=search, 
-        customer_type_id=customer_type_id
-    )
+    params = {"limit": min(limit or 50, 200), "offset": offset or 0}
+
+    if search:
+        params["search"] = search
+    if customer_type_id:
+        params["customer_type_id"] = customer_type_id
+
+    # Basic in-memory cache for lightweight GETs
+    cache_key = f"customers:{limit}:{offset}:{search}:{customer_type_id}"
+    try:
+        cached = _simple_cache_get(cache_key)
+        if cached:
+            return cached
+    except Exception:
+        pass
+
+    # If caller asked to fetch all, use helper to iterate pages
+    if fetch_all:
+        items = await _fetch_all_paginated("/customers", params=params, page_size=200, max_records=max_records)
+        if isinstance(items, dict) and not items.get("success", True):
+            return {"success": False, "error": items.get("error"), "message": items.get("message")}
+
+        customers = items
+        total_count = len(customers)
+        response = {
+            "success": True,
+            "message": f"✅ Encontrados {len(customers)} clientes (fetch_all)",
+            "customers": customers,
+            "count": len(customers),
+            "filters_applied": params,
+        }
+        try:
+            _simple_cache_set(cache_key, response, ttl=30)
+        except Exception:
+            pass
+        return response
+
+    result = await make_sienge_request("GET", "/customers", params=params)
 
     if result["success"]:
         data = result["data"]
@@ -727,34 +338,31 @@ async def get_sienge_customers(
         metadata = data.get("resultSetMetadata", {}) if isinstance(data, dict) else {}
         total_count = metadata.get("count", len(customers))
 
-        return {
+        response = {
             "success": True,
             "message": f"✅ Encontrados {len(customers)} clientes (total: {total_count})",
             "customers": customers,
             "count": len(customers),
-            "total_count": total_count,
-            "filters_applied": {
-                "limit": limit, "offset": offset, "search": search, "customer_type_id": customer_type_id
-            },
-            "request_id": result.get("request_id"),
-            "latency_ms": result.get("latency_ms"),
-            "cache": result.get("cache")
+            "filters_applied": params,
         }
+        try:
+            _simple_cache_set(cache_key, response, ttl=30)
+        except Exception:
+            pass
+        return response
 
     return {
         "success": False,
         "message": "❌ Erro ao buscar clientes",
         "error": result.get("error"),
         "details": result.get("message"),
-        "request_id": result.get("request_id")
     }
 
 
 @mcp.tool
-async def get_sienge_customer_types(_meta: Optional[Dict] = None) -> Dict:
+async def get_sienge_customer_types() -> Dict:
     """Lista tipos de clientes disponíveis"""
-    # Usar serviço interno
-    result = await _svc_get_customer_types()
+    result = await make_sienge_request("GET", "/customer-types")
 
     if result["success"]:
         data = result["data"]
@@ -762,211 +370,23 @@ async def get_sienge_customer_types(_meta: Optional[Dict] = None) -> Dict:
         metadata = data.get("resultSetMetadata", {}) if isinstance(data, dict) else {}
         total_count = metadata.get("count", len(customer_types))
 
-        return {
+        response = {
             "success": True,
             "message": f"✅ Encontrados {len(customer_types)} tipos de clientes (total: {total_count})",
             "customer_types": customer_types,
             "count": len(customer_types),
-            "total_count": total_count,
-            "request_id": result.get("request_id"),
-            "latency_ms": result.get("latency_ms"),
-            "cache": result.get("cache")
         }
-
-    return {
-        "success": False,
-        "message": "❌ Erro ao buscar tipos de clientes",
-        "error": result.get("error"),
-        "details": result.get("message"),
-        "request_id": result.get("request_id")
-    }
-
-
-# ============ ALIAS COMPATÍVEIS COM CHECKLIST ============
-
-@mcp.tool
-async def get_sienge_enterprises(
-    limit: int = 100, offset: int = 0, company_id: int = None, enterprise_type: int = None,
-    _meta: Optional[Dict] = None) -> Dict:
-    """
-    ALIAS: get_sienge_projects → get_sienge_enterprises
-    Busca empreendimentos/obras (compatibilidade com checklist)
-    """
-    return await get_sienge_projects(
-        limit=limit, 
-        offset=offset, 
-        company_id=company_id, 
-        enterprise_type=enterprise_type
-    )
-
-
-@mcp.tool
-async def get_sienge_suppliers(
-    limit: int = 50,
-    offset: int = 0,
-    search: str = None,
-    _meta: Optional[Dict] = None) -> Dict:
-    """
-    ALIAS: get_sienge_creditors → get_sienge_suppliers
-    Busca fornecedores (compatibilidade com checklist)
-    """
-    return await get_sienge_creditors(limit=limit, offset=offset, search=search)
-
-
-@mcp.tool
-async def search_sienge_finances(
-    period_start: str,
-    period_end: str,
-    account_type: Optional[str] = None,
-    cost_center: Optional[str] = None,   # ignorado por enquanto (não suportado na API atual)
-    amount_filter: Optional[str] = None,
-    customer_creditor: Optional[str] = None
-) -> Dict:
-    """
-    ALIAS: search_sienge_financial_data → search_sienge_finances
-    - account_type: receivable | payable | both
-    - amount_filter: "100..500", ">=1000", "<=500", ">100", "<200", "=750"
-    - customer_creditor: termo de busca (cliente/credor)
-    """
-    # 1) mapear tipo
-    search_type = (account_type or "both").lower()
-    if search_type not in {"receivable", "payable", "both"}:
-        search_type = "both"
-
-    # 2) parse de faixa de valores
-    amount_min = amount_max = None
-    if amount_filter:
-        s = amount_filter.replace(" ", "")
         try:
-            if ".." in s:
-                lo, hi = s.split("..", 1)
-                amount_min = float(lo) if lo else None
-                amount_max = float(hi) if hi else None
-            elif s.startswith(">="):
-                amount_min = float(s[2:])
-            elif s.startswith("<="):
-                amount_max = float(s[2:])
-            elif s.startswith(">"):
-                # >x  → min = x (estrito não suportado; aproximamos)
-                amount_min = float(s[1:])
-            elif s.startswith("<"):
-                amount_max = float(s[1:])
-            elif s.startswith("="):
-                v = float(s[1:])
-                amount_min = v
-                amount_max = v
-            else:
-                # número puro → min
-                amount_min = float(s)
-        except ValueError:
-            # filtro inválido → ignora silenciosamente
-            amount_min = amount_max = None
-
-    return await search_sienge_financial_data(
-        period_start=period_start,
-        period_end=period_end,
-        search_type=search_type,
-        amount_min=amount_min,
-        amount_max=amount_max,
-        customer_creditor_search=customer_creditor
-    )
-
-
-@mcp.tool
-async def get_sienge_accounts_payable(
-    start_date: str = None, end_date: str = None, creditor_id: str = None, 
-    status: str = None, limit: int = 50,
-    _meta: Optional[Dict] = None) -> Dict:
-    """
-    ALIAS: get_sienge_bills → get_sienge_accounts_payable
-    Busca contas a pagar (compatibilidade com checklist)
-    """
-    return await get_sienge_bills(
-        start_date=start_date,
-        end_date=end_date,
-        creditor_id=creditor_id,
-        status=status,
-        limit=limit
-    )
-
-
-@mcp.tool
-async def list_sienge_purchase_invoices(limit: int = 50, date_from: str = None,
-    _meta: Optional[Dict] = None) -> Dict:
-    """
-    Lista notas fiscais de compra (versão list/plural esperada pelo checklist)
-    
-    Args:
-        limit: Máximo de registros (padrão: 50, máx: 200)
-        date_from: Data inicial (YYYY-MM-DD)
-    """
-    # Usar serviço interno
-    result = await _svc_get_purchase_invoices(limit=limit, date_from=date_from)
-    
-    if result["success"]:
-        data = result["data"]
-        invoices = data.get("results", []) if isinstance(data, dict) else data
-        metadata = data.get("resultSetMetadata", {}) if isinstance(data, dict) else {}
-        total_count = metadata.get("count", len(invoices))
-
-        return {
-            "success": True,
-            "message": f"✅ Encontradas {len(invoices)} notas fiscais de compra (total: {total_count})",
-            "purchase_invoices": invoices,
-            "count": len(invoices),
-            "total_count": total_count,
-            "filters_applied": {"limit": limit, "date_from": date_from},
-            "request_id": result.get("request_id"),
-            "latency_ms": result.get("latency_ms"),
-            "cache": result.get("cache")
-        }
-
-    return {
-        "success": False,
-        "message": "❌ Erro ao buscar notas fiscais de compra",
-        "error": result.get("error"),
-        "details": result.get("message"),
-        "request_id": result.get("request_id")
-    }
-
-
-@mcp.tool
-async def list_sienge_purchase_requests(limit: int = 50, status: str = None,
-    _meta: Optional[Dict] = None) -> Dict:
-    """
-    Lista solicitações de compra (versão list/plural esperada pelo checklist)
-    
-    Args:
-        limit: Máximo de registros (padrão: 50, máx: 200)
-        status: Status da solicitação
-    """
-    # Usar serviço interno
-    result = await _svc_get_purchase_requests(limit=limit, status=status)
-    
-    if result["success"]:
-        data = result["data"]
-        requests = data.get("results", []) if isinstance(data, dict) else data
-        metadata = data.get("resultSetMetadata", {}) if isinstance(data, dict) else {}
-        total_count = metadata.get("count", len(requests))
-
-        return {
-            "success": True,
-            "message": f"✅ Encontradas {len(requests)} solicitações de compra (total: {total_count})",
-            "purchase_requests": requests,
-            "count": len(requests),
-            "total_count": total_count,
-            "filters_applied": {"limit": limit, "status": status},
-            "request_id": result.get("request_id"),
-            "latency_ms": result.get("latency_ms"),
-            "cache": result.get("cache")
-        }
+            _simple_cache_set("customer_types", response, ttl=300)
+        except Exception:
+            pass
+        return response
 
     return {
         "success": False,
-        "message": "❌ Erro ao buscar solicitações de compra",
+        "message": "❌ Erro ao buscar tipos de clientes",
         "error": result.get("error"),
         "details": result.get("message"),
-        "request_id": result.get("request_id")
     }
 
 
@@ -974,8 +394,13 @@ async def list_sienge_purchase_requests(limit: int = 50, status: str = None,
 
 
 @mcp.tool
-async def get_sienge_creditors(limit: Optional[int] = 50, offset: Optional[int] = 0, search: Optional[str] = None,
-    _meta: Optional[Dict] = None) -> Dict:
+async def get_sienge_creditors(
+    limit: Optional[int] = 50,
+    offset: Optional[int] = 0,
+    search: Optional[str] = None,
+    fetch_all: Optional[bool] = False,
+    max_records: Optional[int] = None,
+) -> Dict:
     """
     Busca credores/fornecedores
 
@@ -984,12 +409,38 @@ async def get_sienge_creditors(limit: Optional[int] = 50, offset: Optional[int]
         offset: Pular registros (padrão: 0)
         search: Buscar por nome
     """
-    # Usar serviço interno
-    result = await _svc_get_creditors(
-        limit=limit or 50,
-        offset=offset or 0,
-        search=search
-    )
+    params = {"limit": min(limit or 50, 200), "offset": offset or 0}
+    if search:
+        params["search"] = search
+
+    cache_key = f"creditors:{limit}:{offset}:{search}:{fetch_all}:{max_records}"
+    try:
+        cached = _simple_cache_get(cache_key)
+        if cached:
+            return cached
+    except Exception:
+        pass
+
+    # Support fetching all pages when requested
+    if fetch_all:
+        items = await _fetch_all_paginated("/creditors", params=params, page_size=200, max_records=max_records)
+        if isinstance(items, dict) and not items.get("success", True):
+            return {"success": False, "error": items.get("error"), "message": items.get("message")}
+
+        creditors = items
+        response = {
+            "success": True,
+            "message": f"✅ Encontrados {len(creditors)} credores (fetch_all)",
+            "creditors": creditors,
+            "count": len(creditors),
+        }
+        try:
+            _simple_cache_set(cache_key, response, ttl=30)
+        except Exception:
+            pass
+        return response
+
+    result = await make_sienge_request("GET", "/creditors", params=params)
 
     if result["success"]:
         data = result["data"]
@@ -997,38 +448,35 @@ async def get_sienge_creditors(limit: Optional[int] = 50, offset: Optional[int]
         metadata = data.get("resultSetMetadata", {}) if isinstance(data, dict) else {}
         total_count = metadata.get("count", len(creditors))
 
-        return {
+        response = {
             "success": True,
             "message": f"✅ Encontrados {len(creditors)} credores (total: {total_count})",
             "creditors": creditors,
             "count": len(creditors),
-            "total_count": total_count,
-            "filters_applied": {"limit": limit, "offset": offset, "search": search},
-            "request_id": result.get("request_id"),
-            "latency_ms": result.get("latency_ms"),
-            "cache": result.get("cache")
         }
+        try:
+            _simple_cache_set(cache_key, response, ttl=30)
+        except Exception:
+            pass
+        return response
 
     return {
         "success": False,
         "message": "❌ Erro ao buscar credores",
         "error": result.get("error"),
         "details": result.get("message"),
-        "request_id": result.get("request_id")
     }
 
 
 @mcp.tool
-async def get_sienge_creditor_bank_info(creditor_id: str,
-    _meta: Optional[Dict] = None) -> Dict:
+async def get_sienge_creditor_bank_info(creditor_id: str) -> Dict:
     """
     Consulta informações bancárias de um credor
 
     Args:
         creditor_id: ID do credor (obrigatório)
     """
-    # Usar serviço interno
-    result = await _svc_get_creditor_bank_info(creditor_id=creditor_id)
+    result = await make_sienge_request("GET", f"/creditors/{creditor_id}/bank-informations")
 
     if result["success"]:
         return {
@@ -1036,8 +484,6 @@ async def get_sienge_creditor_bank_info(creditor_id: str,
             "message": f"✅ Informações bancárias do credor {creditor_id}",
             "creditor_id": creditor_id,
             "bank_info": result["data"],
-            "request_id": result.get("request_id"),
-            "latency_ms": result.get("latency_ms")
         }
 
     return {
@@ -1045,7 +491,6 @@ async def get_sienge_creditor_bank_info(creditor_id: str,
         "message": f"❌ Erro ao buscar info bancária do credor {creditor_id}",
         "error": result.get("error"),
         "details": result.get("message"),
-        "request_id": result.get("request_id")
     }
 
 
@@ -1066,10 +511,9 @@ async def get_sienge_accounts_receivable(
     origins_ids: Optional[List[str]] = None,
     bearers_id_in: Optional[List[int]] = None,
     bearers_id_not_in: Optional[List[int]] = None,
-    _meta: Optional[Dict] = None) -> Dict:
+) -> Dict:
     """
     Consulta parcelas do contas a receber via API bulk-data
-    MELHORADO: Suporte a polling assíncrono para requests 202
 
     Args:
         start_date: Data de início do período (YYYY-MM-DD) - OBRIGATÓRIO
@@ -1085,121 +529,90 @@ async def get_sienge_accounts_receivable(
         bearers_id_in: Filtrar parcelas com códigos de portador específicos
         bearers_id_not_in: Filtrar parcelas excluindo códigos de portador específicos
     """
-    # Usar serviço interno com polling assíncrono
-    result = await _svc_get_accounts_receivable(
-        start_date=start_date,
-        end_date=end_date,
-        selection_type=selection_type,
-        company_id=company_id,
-        cost_centers_id=cost_centers_id,
-        correction_indexer_id=correction_indexer_id,
-        correction_date=correction_date,
-        change_start_date=change_start_date,
-        completed_bills=completed_bills,
-        origins_ids=origins_ids,
-        bearers_id_in=bearers_id_in,
-        bearers_id_not_in=bearers_id_not_in
-    )
+    params = {"startDate": start_date, "endDate": end_date, "selectionType": selection_type}
+
+    if company_id:
+        params["companyId"] = company_id
+    if cost_centers_id:
+        params["costCentersId"] = cost_centers_id
+    if correction_indexer_id:
+        params["correctionIndexerId"] = correction_indexer_id
+    if correction_date:
+        params["correctionDate"] = correction_date
+    if change_start_date:
+        params["changeStartDate"] = change_start_date
+    if completed_bills:
+        params["completedBills"] = completed_bills
+    if origins_ids:
+        params["originsIds"] = origins_ids
+    if bearers_id_in:
+        params["bearersIdIn"] = bearers_id_in
+    if bearers_id_not_in:
+        params["bearersIdNotIn"] = bearers_id_not_in
+
+    result = await make_sienge_bulk_request("GET", "/income", params=params)
 
     if result["success"]:
-        # Para requests normais (200) e assíncronos processados
-        income_data = result.get("data", [])
-        
-        response = {
+        data = result["data"]
+        income_data = data.get("data", []) if isinstance(data, dict) else data
+
+        return {
             "success": True,
             "message": f"✅ Encontradas {len(income_data)} parcelas a receber",
             "income_data": income_data,
             "count": len(income_data),
             "period": f"{start_date} a {end_date}",
             "selection_type": selection_type,
-            "request_id": result.get("request_id"),
-            "latency_ms": result.get("latency_ms")
+            "filters": params,
         }
-        
-        # Se foi processamento assíncrono, incluir informações extras
-        if result.get("async_identifier"):
-            response.update({
-                "async_processing": {
-                    "identifier": result.get("async_identifier"),
-                    "correlation_id": result.get("correlation_id"),
-                    "chunks_downloaded": result.get("chunks_downloaded"),
-                    "rows_returned": result.get("rows_returned"),
-                    "polling_attempts": result.get("polling_attempts")
-                }
-            })
-        
-        return response
 
     return {
         "success": False,
         "message": "❌ Erro ao buscar parcelas a receber",
         "error": result.get("error"),
         "details": result.get("message"),
-        "request_id": result.get("request_id"),
-        "async_info": {
-            "identifier": result.get("async_identifier"),
-            "polling_attempts": result.get("polling_attempts")
-        } if result.get("async_identifier") else None
     }
 
 
 @mcp.tool
 async def get_sienge_accounts_receivable_by_bills(
-    bills_ids: List[int], correction_indexer_id: Optional[int] = None, correction_date: Optional[str] = None,
-    _meta: Optional[Dict] = None) -> Dict:
+    bills_ids: List[int], correction_indexer_id: Optional[int] = None, correction_date: Optional[str] = None
+) -> Dict:
     """
     Consulta parcelas dos títulos informados via API bulk-data
-    MELHORADO: Suporte a polling assíncrono para requests 202
 
     Args:
         bills_ids: Lista de códigos dos títulos - OBRIGATÓRIO
         correction_indexer_id: Código do indexador de correção
         correction_date: Data para correção do indexador (YYYY-MM-DD)
     """
-    # Usar serviço interno com polling assíncrono
-    result = await _svc_get_accounts_receivable_by_bills(
-        bills_ids=bills_ids,
-        correction_indexer_id=correction_indexer_id,
-        correction_date=correction_date
-    )
+    params = {"billsIds": bills_ids}
+
+    if correction_indexer_id:
+        params["correctionIndexerId"] = correction_indexer_id
+    if correction_date:
+        params["correctionDate"] = correction_date
+
+    result = await make_sienge_bulk_request("GET", "/income/by-bills", params=params)
 
     if result["success"]:
-        income_data = result.get("data", [])
-        
-        response = {
+        data = result["data"]
+        income_data = data.get("data", []) if isinstance(data, dict) else data
+
+        return {
             "success": True,
             "message": f"✅ Encontradas {len(income_data)} parcelas dos títulos informados",
             "income_data": income_data,
             "count": len(income_data),
             "bills_consulted": bills_ids,
-            "request_id": result.get("request_id"),
-            "latency_ms": result.get("latency_ms")
+            "filters": params,
         }
-        
-        # Se foi processamento assíncrono, incluir informações extras
-        if result.get("async_identifier"):
-            response.update({
-                "async_processing": {
-                    "identifier": result.get("async_identifier"),
-                    "correlation_id": result.get("correlation_id"),
-                    "chunks_downloaded": result.get("chunks_downloaded"),
-                    "rows_returned": result.get("rows_returned"),
-                    "polling_attempts": result.get("polling_attempts")
-                }
-            })
-        
-        return response
 
     return {
         "success": False,
         "message": "❌ Erro ao buscar parcelas dos títulos informados",
         "error": result.get("error"),
         "details": result.get("message"),
-        "request_id": result.get("request_id"),
-        "async_info": {
-            "identifier": result.get("async_identifier"),
-            "polling_attempts": result.get("polling_attempts")
-        } if result.get("async_identifier") else None
     }
 
 
@@ -1210,7 +623,7 @@ async def get_sienge_bills(
     creditor_id: Optional[str] = None,
     status: Optional[str] = None,
     limit: Optional[int] = 50,
-    _meta: Optional[Dict] = None) -> Dict:
+) -> Dict:
     """
     Consulta títulos a pagar (contas a pagar) - REQUER startDate obrigatório
 
@@ -1221,14 +634,26 @@ async def get_sienge_bills(
         status: Status do título (ex: open, paid, cancelled)
         limit: Máximo de registros (padrão: 50, máx: 200)
     """
-    # Usar serviço interno
-    result = await _svc_get_bills(
-        start_date=start_date,
-        end_date=end_date,
-        creditor_id=creditor_id,
-        status=status,
-        limit=limit or 50
-    )
+    from datetime import datetime, timedelta
+
+    # Se start_date não fornecido, usar últimos 30 dias
+    if not start_date:
+        start_date = (datetime.now() - timedelta(days=30)).strftime("%Y-%m-%d")
+
+    # Se end_date não fornecido, usar hoje
+    if not end_date:
+        end_date = datetime.now().strftime("%Y-%m-%d")
+
+    # Parâmetros obrigatórios
+    params = {"startDate": start_date, "endDate": end_date, "limit": min(limit or 50, 200)}  # OBRIGATÓRIO pela API
+
+    # Parâmetros opcionais
+    if creditor_id:
+        params["creditor_id"] = creditor_id
+    if status:
+        params["status"] = status
+
+    result = await make_sienge_request("GET", "/bills", params=params)
 
     if result["success"]:
         data = result["data"]
@@ -1236,33 +661,14 @@ async def get_sienge_bills(
         metadata = data.get("resultSetMetadata", {}) if isinstance(data, dict) else {}
         total_count = metadata.get("count", len(bills))
 
-        # Aplicar parsing numérico nos valores
-        for bill in bills:
-            if "amount" in bill:
-                bill["amount"] = _parse_numeric_value(bill["amount"])
-            if "paid_amount" in bill:
-                bill["paid_amount"] = _parse_numeric_value(bill["paid_amount"])
-            if "remaining_amount" in bill:
-                bill["remaining_amount"] = _parse_numeric_value(bill["remaining_amount"])
-
-        # Usar datas padrão se não fornecidas
-        actual_start = start_date or (datetime.now() - timedelta(days=30)).strftime("%Y-%m-%d")
-        actual_end = end_date or datetime.now().strftime("%Y-%m-%d")
-
         return {
             "success": True,
-            "message": f"✅ Encontrados {len(bills)} títulos a pagar (total: {total_count}) - período: {actual_start} a {actual_end}",
+            "message": f"✅ Encontrados {len(bills)} títulos a pagar (total: {total_count}) - período: {start_date} a {end_date}",
             "bills": bills,
             "count": len(bills),
             "total_count": total_count,
-            "period": {"start_date": actual_start, "end_date": actual_end},
-            "filters_applied": {
-                "start_date": actual_start, "end_date": actual_end, 
-                "creditor_id": creditor_id, "status": status, "limit": limit
-            },
-            "request_id": result.get("request_id"),
-            "latency_ms": result.get("latency_ms"),
-            "cache": result.get("cache")
+            "period": {"start_date": start_date, "end_date": end_date},
+            "filters": params,
         }
 
     return {
@@ -1270,7 +676,6 @@ async def get_sienge_bills(
         "message": "❌ Erro ao buscar títulos a pagar",
         "error": result.get("error"),
         "details": result.get("message"),
-        "request_id": result.get("request_id")
     }
 
 
@@ -1283,7 +688,7 @@ async def get_sienge_purchase_orders(
     status: Optional[str] = None,
     date_from: Optional[str] = None,
     limit: Optional[int] = 50,
-    _meta: Optional[Dict] = None) -> Dict:
+) -> Dict:
     """
     Consulta pedidos de compra
 
@@ -1316,8 +721,6 @@ async def get_sienge_purchase_orders(
             "message": f"✅ Encontrados {len(orders)} pedidos de compra",
             "purchase_orders": orders,
             "count": len(orders),
-            "request_id": result.get("request_id"),
-            "latency_ms": result.get("latency_ms")
         }
 
     return {
@@ -1325,14 +728,11 @@ async def get_sienge_purchase_orders(
         "message": "❌ Erro ao buscar pedidos de compra",
         "error": result.get("error"),
         "details": result.get("message"),
-        "request_id": result.get("request_id"),
-        "latency_ms": result.get("latency_ms")
     }
 
 
 @mcp.tool
-async def get_sienge_purchase_order_items(purchase_order_id: str,
-    _meta: Optional[Dict] = None) -> Dict:
+async def get_sienge_purchase_order_items(purchase_order_id: str) -> Dict:
     """
     Consulta itens de um pedido de compra específico
 
@@ -1362,8 +762,7 @@ async def get_sienge_purchase_order_items(purchase_order_id: str,
 
 
 @mcp.tool
-async def get_sienge_purchase_requests(purchase_request_id: Optional[str] = None, limit: Optional[int] = 50,
-    _meta: Optional[Dict] = None) -> Dict:
+async def get_sienge_purchase_requests(purchase_request_id: Optional[str] = None, limit: Optional[int] = 50) -> Dict:
     """
     Consulta solicitações de compra
 
@@ -1404,8 +803,7 @@ async def get_sienge_purchase_requests(purchase_request_id: Optional[str] = None
 
 
 @mcp.tool
-async def create_sienge_purchase_request(description: str, project_id: str, items: List[Dict[str, Any]],
-    _meta: Optional[Dict] = None) -> Dict:
+async def create_sienge_purchase_request(description: str, project_id: str, items: List[Dict[str, Any]]) -> Dict:
     """
     Cria nova solicitação de compra
 
@@ -1421,18 +819,14 @@ async def create_sienge_purchase_request(description: str, project_id: str, item
         "date": datetime.now().strftime("%Y-%m-%d"),
     }
 
-    # CORRIGIDO: Normalizar JSON payload
-    json_data = to_camel_json(request_data)
-    result = await make_sienge_request("POST", "/purchase-requests", json_data=json_data)
+    result = await make_sienge_request("POST", "/purchase-requests", json_data=request_data)
 
     if result["success"]:
         return {
             "success": True,
             "message": "✅ Solicitação de compra criada com sucesso",
-            "request_id": result.get("request_id"),
-            "purchase_request_id": result["data"].get("id"),
+            "request_id": result["data"].get("id"),
             "data": result["data"],
-            "latency_ms": result.get("latency_ms")
         }
 
     return {
@@ -1440,7 +834,6 @@ async def create_sienge_purchase_request(description: str, project_id: str, item
         "message": "❌ Erro ao criar solicitação de compra",
         "error": result.get("error"),
         "details": result.get("message"),
-        "request_id": result.get("request_id")
     }
 
 
@@ -1448,8 +841,7 @@ async def create_sienge_purchase_request(description: str, project_id: str, item
 
 
 @mcp.tool
-async def get_sienge_purchase_invoice(sequential_number: int,
-    _meta: Optional[Dict] = None) -> Dict:
+async def get_sienge_purchase_invoice(sequential_number: int) -> Dict:
     """
     Consulta nota fiscal de compra por número sequencial
 
@@ -1470,8 +862,7 @@ async def get_sienge_purchase_invoice(sequential_number: int,
 
 
 @mcp.tool
-async def get_sienge_purchase_invoice_items(sequential_number: int,
-    _meta: Optional[Dict] = None) -> Dict:
+async def get_sienge_purchase_invoice_items(sequential_number: int) -> Dict:
     """
     Consulta itens de uma nota fiscal de compra
 
@@ -1512,7 +903,7 @@ async def create_sienge_purchase_invoice(
     issue_date: str,
     series: Optional[str] = None,
     notes: Optional[str] = None,
-    _meta: Optional[Dict] = None) -> Dict:
+) -> Dict:
     """
     Cadastra uma nova nota fiscal de compra
 
@@ -1528,13 +919,13 @@ async def create_sienge_purchase_invoice(
         notes: Observações (opcional)
     """
     invoice_data = {
-        "document_id": document_id,
+        "documentId": document_id,
         "number": number,
-        "supplier_id": supplier_id,
-        "company_id": company_id,
-        "movement_type_id": movement_type_id,
-        "movement_date": movement_date,
-        "issue_date": issue_date,
+        "supplierId": supplier_id,
+        "companyId": company_id,
+        "movementTypeId": movement_type_id,
+        "movementDate": movement_date,
+        "issueDate": issue_date,
     }
 
     if series:
@@ -1542,7 +933,7 @@ async def create_sienge_purchase_invoice(
     if notes:
         invoice_data["notes"] = notes
 
-    result = await make_sienge_request("POST", "/purchase-invoices", json_data=to_camel_json(invoice_data))
+    result = await make_sienge_request("POST", "/purchase-invoices", json_data=invoice_data)
 
     if result["success"]:
         return {"success": True, "message": f"✅ Nota fiscal {number} criada com sucesso", "invoice": result["data"]}
@@ -1562,7 +953,7 @@ async def add_items_to_purchase_invoice(
     copy_notes_purchase_orders: bool = True,
     copy_notes_resources: bool = False,
     copy_attachments_purchase_orders: bool = True,
-    _meta: Optional[Dict] = None) -> Dict:
+) -> Dict:
     """
     Insere itens em uma nota fiscal a partir de entregas de pedidos de compra
 
@@ -1579,14 +970,14 @@ async def add_items_to_purchase_invoice(
         copy_attachments_purchase_orders: Copiar anexos dos pedidos de compra
     """
     item_data = {
-        "deliveries_order": deliveries_order,
-        "copy_notes_purchase_orders": copy_notes_purchase_orders,
-        "copy_notes_resources": copy_notes_resources,
-        "copy_attachments_purchase_orders": copy_attachments_purchase_orders,
+        "deliveriesOrder": deliveries_order,
+        "copyNotesPurchaseOrders": copy_notes_purchase_orders,
+        "copyNotesResources": copy_notes_resources,
+        "copyAttachmentsPurchaseOrders": copy_attachments_purchase_orders,
     }
 
     result = await make_sienge_request(
-        "POST", f"/purchase-invoices/{sequential_number}/items/purchase-orders/delivery-schedules", json_data=to_camel_json(item_data)
+        "POST", f"/purchase-invoices/{sequential_number}/items/purchase-orders/delivery-schedules", json_data=item_data
     )
 
     if result["success"]:
@@ -1613,7 +1004,7 @@ async def get_sienge_purchase_invoices_deliveries_attended(
     purchase_order_item_number: Optional[int] = None,
     limit: Optional[int] = 100,
     offset: Optional[int] = 0,
-    _meta: Optional[Dict] = None) -> Dict:
+) -> Dict:
     """
     Lista entregas atendidas entre pedidos de compra e notas fiscais
 
@@ -1667,8 +1058,7 @@ async def get_sienge_purchase_invoices_deliveries_attended(
 
 
 @mcp.tool
-async def get_sienge_stock_inventory(cost_center_id: str, resource_id: Optional[str] = None,
-    _meta: Optional[Dict] = None) -> Dict:
+async def get_sienge_stock_inventory(cost_center_id: str, resource_id: Optional[str] = None) -> Dict:
     """
     Consulta inventário de estoque por centro de custo
 
@@ -1705,8 +1095,7 @@ async def get_sienge_stock_inventory(cost_center_id: str, resource_id: Optional[
 
 
 @mcp.tool
-async def get_sienge_stock_reservations(limit: Optional[int] = 50,
-    _meta: Optional[Dict] = None) -> Dict:
+async def get_sienge_stock_reservations(limit: Optional[int] = 50) -> Dict:
     """
     Lista reservas de estoque
 
@@ -1746,10 +1135,9 @@ async def get_sienge_projects(
     enterprise_type: Optional[int] = None,
     receivable_register: Optional[str] = None,
     only_buildings_enabled: Optional[bool] = False,
-    _meta: Optional[Dict] = None) -> Dict:
+) -> Dict:
     """
     Busca empreendimentos/obras no Sienge
-    CORRIGIDO: Mapeamento correto da chave de resposta
 
     Args:
         limit: Máximo de registros (padrão: 100, máximo: 200)
@@ -1759,39 +1147,31 @@ async def get_sienge_projects(
         receivable_register: Filtro de registro de recebíveis (B3, CERC)
         only_buildings_enabled: Retornar apenas obras habilitadas para integração orçamentária
     """
-    # Usar serviço interno
-    result = await _svc_get_projects(
-        limit=limit or 100,
-        offset=offset or 0,
-        company_id=company_id,
-        enterprise_type=enterprise_type,
-        receivable_register=receivable_register,
-        only_buildings_enabled=only_buildings_enabled or False
-    )
+    params = {"limit": min(limit or 100, 200), "offset": offset or 0}
+
+    if company_id:
+        params["companyId"] = company_id
+    if enterprise_type:
+        params["type"] = enterprise_type
+    if receivable_register:
+        params["receivableRegister"] = receivable_register
+    if only_buildings_enabled:
+        params["onlyBuildingsEnabledForIntegration"] = only_buildings_enabled
+
+    result = await make_sienge_request("GET", "/enterprises", params=params)
 
     if result["success"]:
         data = result["data"]
-        # CORREÇÃO: API retorna em "results", mas paginador espera em "enterprises"
         enterprises = data.get("results", []) if isinstance(data, dict) else data
         metadata = data.get("resultSetMetadata", {}) if isinstance(data, dict) else {}
-        total_count = metadata.get("count", len(enterprises))
 
         return {
             "success": True,
-            "message": f"✅ Encontrados {len(enterprises)} empreendimentos (total: {total_count})",
-            "enterprises": enterprises,  # Manter consistência para paginador
-            "projects": enterprises,     # Alias para compatibilidade
+            "message": f"✅ Encontrados {len(enterprises)} empreendimentos",
+            "enterprises": enterprises,
             "count": len(enterprises),
-            "total_count": total_count,
             "metadata": metadata,
-            "filters_applied": {
-                "limit": limit, "offset": offset, "company_id": company_id,
-                "enterprise_type": enterprise_type, "receivable_register": receivable_register,
-                "only_buildings_enabled": only_buildings_enabled
-            },
-            "request_id": result.get("request_id"),
-            "latency_ms": result.get("latency_ms"),
-            "cache": result.get("cache")
+            "filters": params,
         }
 
     return {
@@ -1799,13 +1179,11 @@ async def get_sienge_projects(
         "message": "❌ Erro ao buscar empreendimentos",
         "error": result.get("error"),
         "details": result.get("message"),
-        "request_id": result.get("request_id")
     }
 
 
 @mcp.tool
-async def get_sienge_enterprise_by_id(enterprise_id: int,
-    _meta: Optional[Dict] = None) -> Dict:
+async def get_sienge_enterprise_by_id(enterprise_id: int) -> Dict:
     """
     Busca um empreendimento específico por ID no Sienge
 
@@ -1826,8 +1204,7 @@ async def get_sienge_enterprise_by_id(enterprise_id: int,
 
 
 @mcp.tool
-async def get_sienge_enterprise_groupings(enterprise_id: int,
-    _meta: Optional[Dict] = None) -> Dict:
+async def get_sienge_enterprise_groupings(enterprise_id: int) -> Dict:
     """
     Busca agrupamentos de unidades de um empreendimento específico
 
@@ -1854,8 +1231,7 @@ async def get_sienge_enterprise_groupings(enterprise_id: int,
 
 
 @mcp.tool
-async def get_sienge_units(limit: Optional[int] = 50, offset: Optional[int] = 0,
-    _meta: Optional[Dict] = None) -> Dict:
+async def get_sienge_units(limit: Optional[int] = 50, offset: Optional[int] = 0) -> Dict:
     """
     Consulta unidades cadastradas no Sienge
 
@@ -1877,9 +1253,6 @@ async def get_sienge_units(limit: Optional[int] = 50, offset: Optional[int] = 0,
             "message": f"✅ Encontradas {len(units)} unidades (total: {total_count})",
             "units": units,
             "count": len(units),
-            "total_count": total_count,
-            "request_id": result.get("request_id"),
-            "latency_ms": result.get("latency_ms")
         }
 
     return {
@@ -1887,8 +1260,6 @@ async def get_sienge_units(limit: Optional[int] = 50, offset: Optional[int] = 0,
         "message": "❌ Erro ao buscar unidades",
         "error": result.get("error"),
         "details": result.get("message"),
-        "request_id": result.get("request_id"),
-        "latency_ms": result.get("latency_ms")
     }
 
 
@@ -1901,7 +1272,7 @@ async def get_sienge_unit_cost_tables(
     description: Optional[str] = None,
     status: Optional[str] = "Active",
     integration_enabled: Optional[bool] = None,
-    _meta: Optional[Dict] = None) -> Dict:
+) -> Dict:
     """
     Consulta tabelas de custos unitários
 
@@ -1949,8 +1320,8 @@ async def search_sienge_data(
     query: str,
     entity_type: Optional[str] = None,
     limit: Optional[int] = 20,
-    filters: Optional[Dict[str, Any]] = None,
-    _meta: Optional[Dict] = None) -> Dict:
+    filters: Optional[Dict[str, Any]] = None
+) -> Dict:
     """
     Busca universal no Sienge - compatível com ChatGPT/OpenAI MCP
     
@@ -2027,44 +1398,35 @@ async def search_sienge_data(
 
 
 async def _search_specific_entity(entity_type: str, query: str, limit: int, filters: Dict) -> Dict:
-    """
-    Função auxiliar para buscar em uma entidade específica
-    CORRIGIDO: Usa serviços internos, nunca outras tools
-    """
+    """Função auxiliar para buscar em uma entidade específica"""
     
     if entity_type == "customers":
-        result = await _svc_get_customers(limit=limit, search=query)
+        result = await get_sienge_customers(limit=limit, search=query)
         if result["success"]:
-            data = result["data"]
-            customers = data.get("results", []) if isinstance(data, dict) else data
             return {
                 "success": True,
-                "data": customers,
-                "count": len(customers),
+                "data": result["customers"],
+                "count": result["count"],
                 "entity_type": "customers"
             }
     
     elif entity_type == "creditors":
-        result = await _svc_get_creditors(limit=limit, search=query)
+        result = await get_sienge_creditors(limit=limit, search=query)
         if result["success"]:
-            data = result["data"]
-            creditors = data.get("results", []) if isinstance(data, dict) else data
             return {
                 "success": True,
-                "data": creditors,
-                "count": len(creditors),
+                "data": result["creditors"],
+                "count": result["count"],
                 "entity_type": "creditors"
             }
     
     elif entity_type == "projects" or entity_type == "enterprises":
         # Para projetos, usar filtros mais específicos se disponível
         company_id = filters.get("company_id")
-        result = await _svc_get_projects(limit=limit, company_id=company_id)
+        result = await get_sienge_projects(limit=limit, company_id=company_id)
         if result["success"]:
-            data = result["data"]
-            projects = data.get("results", []) if isinstance(data, dict) else data
-            
             # Filtrar por query se fornecida
+            projects = result["enterprises"]
             if query:
                 projects = [
                     p for p in projects 
@@ -2083,27 +1445,23 @@ async def _search_specific_entity(entity_type: str, query: str, limit: int, filt
         # Para títulos, usar data padrão se não especificada
         start_date = filters.get("start_date")
         end_date = filters.get("end_date") 
-        result = await _svc_get_bills(
+        result = await get_sienge_bills(
             start_date=start_date, 
             end_date=end_date, 
             limit=limit
         )
         if result["success"]:
-            data = result["data"]
-            bills = data.get("results", []) if isinstance(data, dict) else data
             return {
                 "success": True,
-                "data": bills,
-                "count": len(bills),
+                "data": result["bills"],
+                "count": result["count"],
                 "entity_type": "bills"
             }
     
     elif entity_type == "purchase_orders":
-        result = await _svc_get_purchase_orders(limit=limit)
+        result = await get_sienge_purchase_orders(limit=limit)
         if result["success"]:
-            data = result["data"]
-            orders = data.get("results", []) if isinstance(data, dict) else data
-            
+            orders = result["purchase_orders"]
             # Filtrar por query se fornecida
             if query:
                 orders = [
@@ -2127,7 +1485,7 @@ async def _search_specific_entity(entity_type: str, query: str, limit: int, filt
 
 
 @mcp.tool
-async def list_sienge_entities(_meta: Optional[Dict] = None) -> Dict:
+async def list_sienge_entities() -> Dict:
     """
     Lista todas as entidades disponíveis no Sienge MCP para busca
     
@@ -2146,28 +1504,28 @@ async def list_sienge_entities(_meta: Optional[Dict] = None) -> Dict:
             "name": "Credores/Fornecedores",
             "description": "Fornecedores e credores cadastrados",
             "search_fields": ["nome", "documento"],
-            "tools": ["get_sienge_creditors", "get_sienge_creditor_bank_info", "get_sienge_suppliers"]
+            "tools": ["get_sienge_creditors", "get_sienge_creditor_bank_info"]
         },
         {
             "type": "projects",
             "name": "Empreendimentos/Obras", 
             "description": "Projetos e obras cadastrados",
             "search_fields": ["código", "descrição", "nome"],
-            "tools": ["get_sienge_projects", "get_sienge_enterprises", "get_sienge_enterprise_by_id"]
+            "tools": ["get_sienge_projects", "get_sienge_enterprise_by_id"]
         },
         {
             "type": "bills",
             "name": "Títulos a Pagar",
             "description": "Contas a pagar e títulos financeiros",
             "search_fields": ["número", "credor", "valor"],
-            "tools": ["get_sienge_bills", "get_sienge_accounts_payable"]
+            "tools": ["get_sienge_bills"]
         },
         {
             "type": "purchase_orders",
             "name": "Pedidos de Compra",
             "description": "Pedidos de compra e solicitações",
             "search_fields": ["id", "descrição", "status"],
-            "tools": ["get_sienge_purchase_orders", "get_sienge_purchase_requests", "list_sienge_purchase_requests"]
+            "tools": ["get_sienge_purchase_orders", "get_sienge_purchase_requests"]
         },
         {
             "type": "invoices",
@@ -2188,14 +1546,7 @@ async def list_sienge_entities(_meta: Optional[Dict] = None) -> Dict:
             "name": "Financeiro",
             "description": "Contas a receber e movimentações financeiras",
             "search_fields": ["período", "cliente", "valor"],
-            "tools": ["get_sienge_accounts_receivable", "search_sienge_financial_data", "search_sienge_finances"]
-        },
-        {
-            "type": "suppliers",
-            "name": "Fornecedores",
-            "description": "Fornecedores e credores cadastrados", 
-            "search_fields": ["código", "nome", "razão social"],
-            "tools": ["get_sienge_suppliers"]
+            "tools": ["get_sienge_accounts_receivable"]
         }
     ]
     
@@ -2215,93 +1566,54 @@ async def list_sienge_entities(_meta: Optional[Dict] = None) -> Dict:
 # ============ PAGINATION E NAVEGAÇÃO ============
 
 
-@mcp.tool 
-async def get_sienge_data_paginated(
+async def _get_data_paginated_internal(
     entity_type: str,
     page: int = 1,
     page_size: int = 20,
     filters: Optional[Dict[str, Any]] = None,
-    sort_by: Optional[str] = None,
-    _meta: Optional[Dict] = None) -> Dict:
-    """
-    Busca dados do Sienge com paginação avançada - compatível com ChatGPT
-    
-    Args:
-        entity_type: Tipo de entidade (customers, creditors, projects, bills, etc.)
-        page: Número da página (começando em 1)
-        page_size: Registros por página (máximo 50)
-        filters: Filtros específicos da entidade
-        sort_by: Campo para ordenação (se suportado)
-    """
+    sort_by: Optional[str] = None
+) -> Dict:
+    """Função interna para paginação (sem decorador @mcp.tool)"""
     page_size = min(page_size, 50)
     offset = (page - 1) * page_size
     
     filters = filters or {}
     
-    # CORRIGIDO: Mapear para serviços internos, não tools
+    # Mapear para os tools existentes com offset
     if entity_type == "customers":
         search = filters.get("search")
         customer_type_id = filters.get("customer_type_id")
-        result = await _svc_get_customers(
+        result = await get_sienge_customers(
             limit=page_size,
             offset=offset, 
             search=search,
             customer_type_id=customer_type_id
         )
-        # CORRIGIDO: Extrair items e total corretamente
-        if result["success"]:
-            data = result["data"]
-            items, total = _extract_items_and_total(data)
-            result["customers"] = items
-            result["count"] = len(items)
-            result["total_count"] = total
         
     elif entity_type == "creditors":
         search = filters.get("search")
-        result = await _svc_get_creditors(
+        result = await get_sienge_creditors(
             limit=page_size,
             offset=offset,
             search=search
         )
-        # CORRIGIDO: Extrair items e total corretamente
-        if result["success"]:
-            data = result["data"]
-            items, total = _extract_items_and_total(data)
-            result["creditors"] = items
-            result["count"] = len(items)
-            result["total_count"] = total
         
     elif entity_type == "projects":
-        result = await _svc_get_projects(
+        result = await get_sienge_projects(
             limit=page_size,
             offset=offset,
             company_id=filters.get("company_id"),
             enterprise_type=filters.get("enterprise_type")
         )
-        # CORRIGIDO: Extrair items e total corretamente
-        if result["success"]:
-            data = result["data"]
-            items, total = _extract_items_and_total(data)
-            result["projects"] = items
-            result["enterprises"] = items  # Para compatibilidade
-            result["count"] = len(items)
-            result["total_count"] = total
         
     elif entity_type == "bills":
-        result = await _svc_get_bills(
+        result = await get_sienge_bills(
             start_date=filters.get("start_date"),
             end_date=filters.get("end_date"),
             creditor_id=filters.get("creditor_id"),
             status=filters.get("status"),
             limit=page_size
         )
-        # CORRIGIDO: Extrair items e total corretamente
-        if result["success"]:
-            data = result["data"]
-            items, total = _extract_items_and_total(data)
-            result["bills"] = items
-            result["count"] = len(items)
-            result["total_count"] = total
         
     else:
         return {
@@ -2336,26 +1648,42 @@ async def get_sienge_data_paginated(
     return result
 
 
-@mcp.tool
-async def search_sienge_financial_data(
-    period_start: str,
-    period_end: str, 
-    search_type: str = "both",
-    amount_min: Optional[float] = None,
-    amount_max: Optional[float] = None,
-    customer_creditor_search: Optional[str] = None,
-    _meta: Optional[Dict] = None) -> Dict:
+@mcp.tool 
+async def get_sienge_data_paginated(
+    entity_type: str,
+    page: int = 1,
+    page_size: int = 20,
+    filters: Optional[Dict[str, Any]] = None,
+    sort_by: Optional[str] = None
+) -> Dict:
     """
-    Busca avançada em dados financeiros do Sienge - Contas a Pagar e Receber
+    Busca dados do Sienge com paginação avançada - compatível com ChatGPT
     
     Args:
-        period_start: Data inicial do período (YYYY-MM-DD)
-        period_end: Data final do período (YYYY-MM-DD)
-        search_type: Tipo de busca ("receivable", "payable", "both")
-        amount_min: Valor mínimo (opcional)
-        amount_max: Valor máximo (opcional)
-        customer_creditor_search: Buscar por nome de cliente/credor (opcional)
+        entity_type: Tipo de entidade (customers, creditors, projects, bills, etc.)
+        page: Número da página (começando em 1)
+        page_size: Registros por página (máximo 50)
+        filters: Filtros específicos da entidade
+        sort_by: Campo para ordenação (se suportado)
     """
+    return await _get_data_paginated_internal(
+        entity_type=entity_type,
+        page=page,
+        page_size=page_size,
+        filters=filters,
+        sort_by=sort_by
+    )
+
+
+async def _search_financial_data_internal(
+    period_start: str,
+    period_end: str, 
+    search_type: str = "both",
+    amount_min: Optional[float] = None,
+    amount_max: Optional[float] = None,
+    customer_creditor_search: Optional[str] = None
+) -> Dict:
+    """Função interna para busca financeira (sem decorador @mcp.tool)"""
     
     financial_results = {
         "receivable": {"success": False, "data": [], "count": 0, "error": None},
@@ -2365,21 +1693,20 @@ async def search_sienge_financial_data(
     # Buscar contas a receber
     if search_type in ["receivable", "both"]:
         try:
-            # CORRIGIDO: Usar serviço interno
-            receivable_result = await _svc_get_accounts_receivable(
+            receivable_result = await get_sienge_accounts_receivable(
                 start_date=period_start,
                 end_date=period_end,
                 selection_type="D"  # Por vencimento
             )
             
             if receivable_result["success"]:
-                receivable_data = receivable_result.get("data", [])
+                receivable_data = receivable_result["income_data"]
                 
-                # CORRIGIDO: Aplicar filtros de valor usando _parse_numeric_value
+                # Aplicar filtros de valor se especificados
                 if amount_min is not None or amount_max is not None:
                     filtered_data = []
                     for item in receivable_data:
-                        amount = _parse_numeric_value(item.get("amount", 0))
+                        amount = float(item.get("amount", 0) or 0)
                         if amount_min is not None and amount < amount_min:
                             continue
                         if amount_max is not None and amount > amount_max:
@@ -2412,22 +1739,20 @@ async def search_sienge_financial_data(
     # Buscar contas a pagar  
     if search_type in ["payable", "both"]:
         try:
-            # CORRIGIDO: Usar serviço interno
-            payable_result = await _svc_get_bills(
+            payable_result = await get_sienge_bills(
                 start_date=period_start,
                 end_date=period_end,
                 limit=100
             )
             
             if payable_result["success"]:
-                data = payable_result["data"]
-                payable_data = data.get("results", []) if isinstance(data, dict) else data
+                payable_data = payable_result["bills"]
                 
-                # CORRIGIDO: Aplicar filtros de valor usando _parse_numeric_value
+                # Aplicar filtros de valor se especificados
                 if amount_min is not None or amount_max is not None:
                     filtered_data = []
                     for item in payable_data:
-                        amount = _parse_numeric_value(item.get("amount", 0))
+                        amount = float(item.get("amount", 0) or 0)
                         if amount_min is not None and amount < amount_min:
                             continue
                         if amount_max is not None and amount > amount_max:
@@ -2494,50 +1819,39 @@ async def search_sienge_financial_data(
         }
 
 
-async def _svc_test_connection() -> Dict:
-    """Serviço interno: testar conexão com a API do Sienge"""
-    try:
-        # Usar serviço interno
-        result = await _svc_get_customer_types()
-
-        if result["success"]:
-            auth_method = "Bearer Token" if SIENGE_API_KEY else "Basic Auth"
-            return {
-                "success": True,
-                "message": "✅ Conexão com API do Sienge estabelecida com sucesso!",
-                "api_status": "Online",
-                "auth_method": auth_method,
-                "timestamp": datetime.now().isoformat(),
-                "request_id": result.get("request_id"),
-                "latency_ms": result.get("latency_ms"),
-                "cache": result.get("cache")
-            }
-        else:
-            return {
-                "success": False,
-                "message": "❌ Falha ao conectar com API do Sienge",
-                "error": result.get("error"),
-                "details": result.get("message"),
-                "timestamp": datetime.now().isoformat(),
-                "request_id": result.get("request_id")
-            }
-    except Exception as e:
-        return {
-            "success": False,
-            "message": "❌ Erro ao testar conexão",
-            "error": str(e),
-            "timestamp": datetime.now().isoformat(),
-        }
-
-
 @mcp.tool
-async def test_sienge_connection(_meta: Optional[Dict] = None) -> Dict:
-    """Testa a conexão com a API do Sienge"""
-    return await _svc_test_connection()
+async def search_sienge_financial_data(
+    period_start: str,
+    period_end: str, 
+    search_type: str = "both",
+    amount_min: Optional[float] = None,
+    amount_max: Optional[float] = None,
+    customer_creditor_search: Optional[str] = None
+) -> Dict:
+    """
+    Busca avançada em dados financeiros do Sienge - Contas a Pagar e Receber
+    
+    Args:
+        period_start: Data inicial do período (YYYY-MM-DD)
+        period_end: Data final do período (YYYY-MM-DD)
+        search_type: Tipo de busca ("receivable", "payable", "both")
+        amount_min: Valor mínimo (opcional)
+        amount_max: Valor máximo (opcional)
+        customer_creditor_search: Buscar por nome de cliente/credor (opcional)
+    """
+    return await _search_financial_data_internal(
+        period_start=period_start,
+        period_end=period_end,
+        search_type=search_type,
+        amount_min=amount_min,
+        amount_max=amount_max,
+        customer_creditor_search=customer_creditor_search
+    )
 
 
-async def _svc_get_dashboard_summary() -> Dict:
-    """Serviço interno: obter resumo do dashboard"""
+async def _get_dashboard_summary_internal() -> Dict:
+    """Função interna para dashboard (sem decorador @mcp.tool)"""
+    
     # Data atual e períodos
     today = datetime.now()
     current_month_start = today.replace(day=1).strftime("%Y-%m-%d")
@@ -2548,7 +1862,7 @@ async def _svc_get_dashboard_summary() -> Dict:
     
     # 1. Testar conexão
     try:
-        connection_test = await _svc_test_connection()
+        connection_test = await test_sienge_connection()
         dashboard_data["connection"] = connection_test
     except Exception as e:
         errors.append(f"Teste de conexão: {str(e)}")
@@ -2556,24 +1870,23 @@ async def _svc_get_dashboard_summary() -> Dict:
     
     # 2. Contar clientes (amostra)
     try:
-        customers_result = await _svc_get_customers(limit=1)
-        dashboard_data["customers_available"] = customers_result["success"]
+        customers_result = await get_sienge_customers(limit=1)
+        if customers_result["success"]:
+            dashboard_data["customers_available"] = True
+        else:
+            dashboard_data["customers_available"] = False
     except Exception as e:
         errors.append(f"Clientes: {str(e)}")
         dashboard_data["customers_available"] = False
     
     # 3. Contar projetos (amostra)
     try:
-        projects_result = await _svc_get_projects(limit=5)
+        projects_result = await get_sienge_projects(limit=5)
         if projects_result["success"]:
-            data = projects_result["data"]
-            enterprises = data.get("results", []) if isinstance(data, dict) else data
-            metadata = data.get("resultSetMetadata", {}) if isinstance(data, dict) else {}
-            
             dashboard_data["projects"] = {
                 "available": True,
-                "sample_count": len(enterprises),
-                "total_count": metadata.get("count", "N/A")
+                "sample_count": len(projects_result["enterprises"]),
+                "total_count": projects_result.get("metadata", {}).get("count", "N/A")
             }
         else:
             dashboard_data["projects"] = {"available": False}
@@ -2583,20 +1896,16 @@ async def _svc_get_dashboard_summary() -> Dict:
     
     # 4. Títulos a pagar do mês atual
     try:
-        bills_result = await _svc_get_bills(
+        bills_result = await get_sienge_bills(
             start_date=current_month_start,
             end_date=current_month_end,
             limit=10
         )
         if bills_result["success"]:
-            data = bills_result["data"]
-            bills = data.get("results", []) if isinstance(data, dict) else data
-            metadata = data.get("resultSetMetadata", {}) if isinstance(data, dict) else {}
-            
             dashboard_data["monthly_bills"] = {
                 "available": True,
-                "count": len(bills),
-                "total_count": metadata.get("count", len(bills))
+                "count": len(bills_result["bills"]),
+                "total_count": bills_result.get("total_count", len(bills_result["bills"]))
             }
         else:
             dashboard_data["monthly_bills"] = {"available": False}
@@ -2606,14 +1915,11 @@ async def _svc_get_dashboard_summary() -> Dict:
     
     # 5. Tipos de clientes
     try:
-        customer_types_result = await _svc_get_customer_types()
+        customer_types_result = await get_sienge_customer_types()
         if customer_types_result["success"]:
-            data = customer_types_result["data"]
-            customer_types = data.get("results", []) if isinstance(data, dict) else data
-            
             dashboard_data["customer_types"] = {
                 "available": True,
-                "count": len(customer_types)
+                "count": len(customer_types_result["customer_types"])
             }
         else:
             dashboard_data["customer_types"] = {"available": False}
@@ -2643,12 +1949,298 @@ async def _svc_get_dashboard_summary() -> Dict:
 
 
 @mcp.tool
-async def get_sienge_dashboard_summary(_meta: Optional[Dict] = None) -> Dict:
+async def get_sienge_dashboard_summary() -> Dict:
     """
     Obtém um resumo tipo dashboard com informações gerais do Sienge
     Útil para visão geral rápida do sistema
     """
-    return await _svc_get_dashboard_summary()
+    return await _get_dashboard_summary_internal()
+
+
+# ============ SUPABASE QUERY TOOLS ============
+
+
+@mcp.tool
+async def query_supabase_database(
+    table_name: str,
+    columns: Optional[str] = "*",
+    filters: Optional[Dict[str, Any]] = None,
+    limit: Optional[int] = 100,
+    order_by: Optional[str] = None,
+    search_term: Optional[str] = None,
+    search_columns: Optional[List[str]] = None
+) -> Dict:
+    """
+    Executa queries no banco de dados Supabase para buscar dados das tabelas do Sienge
+    
+    Args:
+        table_name: Nome da tabela (customers, creditors, enterprises, purchase_invoices, stock_inventories, accounts_receivable, installment_payments, income_installments)
+        columns: Colunas a retornar (padrão: "*")
+        filters: Filtros WHERE como dict {"campo": "valor"}
+        limit: Limite de registros (padrão: 100, máximo: 1000)
+        order_by: Campo para ordenação (ex: "name", "created_at desc")
+        search_term: Termo de busca para busca textual
+        search_columns: Colunas onde fazer busca textual (se não especificado, usa campos de texto principais)
+    
+    Nota: As queries são executadas no schema 'sienge_data' (fixo)
+    """
+    # Validação de parâmetros
+    if not table_name or not isinstance(table_name, str):
+        return {
+            "success": False,
+            "message": "❌ Nome da tabela é obrigatório e deve ser uma string",
+            "error": "INVALID_TABLE_NAME"
+        }
+    
+    if limit is not None and (not isinstance(limit, int) or limit <= 0):
+        return {
+            "success": False,
+            "message": "❌ Limite deve ser um número inteiro positivo",
+            "error": "INVALID_LIMIT"
+        }
+    
+    if limit and limit > 1000:
+        limit = 1000  # Aplicar limite máximo
+    
+    return await _query_supabase_internal(
+        table_name=table_name,
+        columns=columns,
+        filters=filters,
+        limit=limit,
+        order_by=order_by,
+        search_term=search_term,
+        search_columns=search_columns
+    )
+
+
+@mcp.tool
+async def get_supabase_table_info(table_name: Optional[str] = None) -> Dict:
+    """
+    Obtém informações sobre as tabelas disponíveis no Supabase ou detalhes de uma tabela específica
+    
+    Args:
+        table_name: Nome da tabela para obter detalhes (opcional)
+    
+    Nota: As tabelas estão no schema 'sienge_data' (fixo)
+    """
+    if not SUPABASE_AVAILABLE:
+        return {
+            "success": False,
+            "message": "❌ Cliente Supabase não disponível",
+            "error": "SUPABASE_NOT_AVAILABLE"
+        }
+    
+    client = _get_supabase_client()
+    if not client:
+        return {
+            "success": False,
+            "message": "❌ Cliente Supabase não configurado",
+            "error": "SUPABASE_NOT_CONFIGURED"
+        }
+    
+    # Informações das tabelas disponíveis
+    tables_info = {
+        "customers": {
+            "name": "Clientes",
+            "description": "Clientes cadastrados no Sienge",
+            "columns": ["id", "name", "document", "email", "phone", "customer_type_id", "raw", "updated_at", "last_synced_at", "created_at"],
+            "search_fields": ["name", "document", "email"],
+            "indexes": ["document", "name (trigram)", "updated_at"]
+        },
+        "creditors": {
+            "name": "Credores/Fornecedores", 
+            "description": "Fornecedores e credores cadastrados",
+            "columns": ["id", "name", "document", "bank_info", "raw", "updated_at", "last_synced_at", "created_at"],
+            "search_fields": ["name", "document"],
+            "indexes": ["document", "name (trigram)", "updated_at"]
+        },
+        "enterprises": {
+            "name": "Empreendimentos/Obras",
+            "description": "Projetos e obras cadastrados",
+            "columns": ["id", "code", "name", "description", "company_id", "type", "metadata", "raw", "updated_at", "last_synced_at", "created_at"],
+            "search_fields": ["name", "description", "code"],
+            "indexes": ["name (trigram)", "company_id", "updated_at"]
+        },
+        "purchase_invoices": {
+            "name": "Notas Fiscais de Compra",
+            "description": "Notas fiscais de compra",
+            "columns": ["id", "sequential_number", "supplier_id", "company_id", "movement_date", "issue_date", "series", "notes", "raw", "updated_at", "last_synced_at", "created_at"],
+            "search_fields": ["sequential_number", "notes"],
+            "indexes": ["supplier_id", "sequential_number", "updated_at"]
+        },
+        "installment_payments": {
+            "name": "Pagamentos de Parcelas",
+            "description": "Pagamentos efetuados para parcelas",
+            "columns": [
+                "id", "installment_uid", "amount", "payment_date", "method", "raw",
+                "updated_at", "last_synced_at", "created_at"
+            ],
+            "search_fields": ["installment_uid"],
+            "indexes": ["payment_date", "installment_uid", "updated_at"]
+        },
+        "income_installments": {
+            "name": "Parcelas de Receita",
+            "description": "Parcelas de contas a receber (busca apenas por valores numéricos)",
+            "columns": [
+                "id", "bill_id", "customer_id", "amount", "due_date", "status", "raw",
+                "updated_at", "last_synced_at", "created_at"
+            ],
+            "search_fields": ["bill_id (numérico)", "customer_id (numérico)", "amount (numérico)"],
+            "indexes": ["due_date", "status", "updated_at"],
+            "search_note": "Para buscar nesta tabela, use valores numéricos (ex: '123' para bill_id)"
+        },
+        "stock_inventories": {
+            "name": "Inventário de Estoque",
+            "description": "Inventário e movimentações de estoque",
+            "columns": ["id", "cost_center_id", "resource_id", "inventory", "raw", "updated_at", "last_synced_at", "created_at"],
+            "search_fields": ["cost_center_id", "resource_id"],
+            "indexes": ["cost_center_id", "resource_id"]
+        },
+        "accounts_receivable": {
+            "name": "Contas a Receber",
+            "description": "Contas a receber e movimentações financeiras",
+            "columns": ["id", "bill_id", "customer_id", "amount", "due_date", "payment_date", "raw", "updated_at", "last_synced_at", "created_at"],
+            "search_fields": ["bill_id", "customer_id"],
+            "indexes": ["customer_id", "due_date", "updated_at"]
+        },
+        "sync_meta": {
+            "name": "Metadados de Sincronização",
+            "description": "Controle de sincronização entre Sienge e Supabase",
+            "columns": ["id", "entity_name", "last_synced_at", "last_record_count", "notes", "created_at"],
+            "search_fields": ["entity_name"],
+            "indexes": ["entity_name"]
+        }
+    }
+    
+    if table_name:
+        if table_name in tables_info:
+            return {
+                "success": True,
+                "message": f"✅ Informações da tabela '{table_name}'",
+                "table_info": tables_info[table_name],
+                "table_name": table_name
+            }
+        else:
+            return {
+                "success": False,
+                "message": f"❌ Tabela '{table_name}' não encontrada",
+                "error": "TABLE_NOT_FOUND",
+                "available_tables": list(tables_info.keys())
+            }
+    else:
+        return {
+            "success": True,
+            "message": f"✅ {len(tables_info)} tabelas disponíveis no Supabase",
+            "schema": SUPABASE_SCHEMA,
+            "tables": tables_info,
+            "usage_examples": {
+                "query_customers": "query_supabase_database('customers', search_term='João')",
+                "query_bills_by_date": "query_supabase_database('bills', filters={'due_date': '2024-01-01'})",
+                "query_enterprises": "query_supabase_database('enterprises', columns='id,name,description', limit=50)"
+            }
+        }
+
+
+@mcp.tool
+async def search_supabase_data(
+    search_term: str,
+    table_names: Optional[List[str]] = None,
+    limit_per_table: Optional[int] = 20
+) -> Dict:
+    """
+    Busca universal em múltiplas tabelas do Supabase
+    
+    Args:
+        search_term: Termo de busca
+        table_names: Lista de tabelas para buscar (se não especificado, busca em todas)
+        limit_per_table: Limite de resultados por tabela (padrão: 20)
+    """
+    # Validação de parâmetros
+    if not search_term or not isinstance(search_term, str):
+        return {
+            "success": False,
+            "message": "❌ Termo de busca é obrigatório e deve ser uma string",
+            "error": "INVALID_SEARCH_TERM"
+        }
+    
+    if limit_per_table is not None and (not isinstance(limit_per_table, int) or limit_per_table <= 0):
+        return {
+            "success": False,
+            "message": "❌ Limite por tabela deve ser um número inteiro positivo",
+            "error": "INVALID_LIMIT"
+        }
+    
+    # Validar e processar table_names
+    if table_names is not None:
+        if not isinstance(table_names, list):
+            return {
+                "success": False,
+                "message": "❌ table_names deve ser uma lista de strings",
+                "error": "INVALID_TABLE_NAMES"
+            }
+        # Filtrar apenas tabelas válidas
+        valid_tables = ["customers", "creditors", "enterprises", "purchase_invoices", 
+                       "stock_inventories", "accounts_receivable", "sync_meta",
+                       "installment_payments", "income_installments"]
+        table_names = [t for t in table_names if t in valid_tables]
+        if not table_names:
+            return {
+                "success": False,
+                "message": "❌ Nenhuma tabela válida especificada",
+                "error": "NO_VALID_TABLES",
+                "valid_tables": valid_tables
+            }
+    else:
+        table_names = ["customers", "creditors", "enterprises", "installment_payments", "income_installments"]
+    
+    results = {}
+    total_found = 0
+    
+    for table_name in table_names:
+        try:
+            # Chamar a função interna diretamente
+            result = await _query_supabase_internal(
+                table_name=table_name,
+                search_term=search_term,
+                limit=limit_per_table or 20
+            )
+            
+            if result["success"]:
+                results[table_name] = {
+                    "count": result["count"],
+                    "data": result["data"][:5] if result["count"] > 5 else result["data"],  # Limitar preview
+                    "has_more": result["count"] > 5
+                }
+                total_found += result["count"]
+            else:
+                results[table_name] = {
+                    "error": result.get("error"),
+                    "count": 0
+                }
+                
+        except Exception as e:
+            results[table_name] = {
+                "error": str(e),
+                "count": 0
+            }
+    
+    if total_found > 0:
+        return {
+            "success": True,
+            "message": f"✅ Busca '{search_term}' encontrou {total_found} registros em {len([t for t in results.values() if t.get('count', 0) > 0])} tabelas",
+            "search_term": search_term,
+            "total_found": total_found,
+            "results_by_table": results,
+            "suggestion": "Use query_supabase_database() para buscar especificamente em uma tabela e obter mais resultados"
+        }
+    else:
+        return {
+            "success": False,
+            "message": f"❌ Nenhum resultado encontrado para '{search_term}'",
+            "search_term": search_term,
+            "searched_tables": table_names,
+            "results_by_table": results
+        }
 
 
 # ============ UTILITÁRIOS ============
@@ -2660,21 +2252,6 @@ def add(a: int, b: int) -> int:
     return a + b
 
 
-def _mask(s: str) -> str:
-    """Mascara dados sensíveis mantendo apenas o início e fim"""
-    if not s:
-        return None
-    if len(s) == 1:
-        return s + "*"
-    if len(s) == 2:
-        return s
-    if len(s) <= 4:
-        return s[:2] + "*" * (len(s) - 2)
-    # Para strings > 4: usar no máximo 4 asteriscos no meio
-    middle_asterisks = min(4, len(s) - 4)
-    return s[:2] + "*" * middle_asterisks + s[-2:]
-
-
 def _get_auth_info_internal() -> Dict:
     """Função interna para verificar configuração de autenticação"""
     if SIENGE_API_KEY and SIENGE_API_KEY != "sua_api_key_aqui":
@@ -2685,7 +2262,7 @@ def _get_auth_info_internal() -> Dict:
             "configured": True,
             "base_url": SIENGE_BASE_URL,
             "subdomain": SIENGE_SUBDOMAIN,
-            "username": _mask(SIENGE_USERNAME) if SIENGE_USERNAME else None,
+            "username": SIENGE_USERNAME,
         }
     else:
         return {
@@ -2695,6 +2272,262 @@ def _get_auth_info_internal() -> Dict:
         }
 
 
+def _get_supabase_client() -> Optional[Client]:
+    """Função interna para obter cliente do Supabase"""
+    if not SUPABASE_AVAILABLE:
+        return None
+    if not SUPABASE_URL or not SUPABASE_SERVICE_ROLE_KEY:
+        return None
+    try:
+        client = create_client(SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY)
+        return client
+    except Exception as e:
+        logger.warning(f"Erro ao criar cliente Supabase: {e}")
+        return None
+
+
+async def _query_supabase_internal(
+    table_name: str,
+    columns: Optional[str] = "*",
+    filters: Optional[Dict[str, Any]] = None,
+    limit: Optional[int] = 100,
+    order_by: Optional[str] = None,
+    search_term: Optional[str] = None,
+    search_columns: Optional[List[str]] = None
+) -> Dict:
+    """Função interna para query no Supabase (sem decorador @mcp.tool)"""
+    
+    if not SUPABASE_AVAILABLE:
+        return {
+            "success": False,
+            "message": "❌ Cliente Supabase não disponível. Instale: pip install supabase",
+            "error": "SUPABASE_NOT_AVAILABLE"
+        }
+    
+    client = _get_supabase_client()
+    if not client:
+        return {
+            "success": False,
+            "message": "❌ Cliente Supabase não configurado. Configure SUPABASE_URL e SUPABASE_SERVICE_ROLE_KEY",
+            "error": "SUPABASE_NOT_CONFIGURED"
+        }
+    
+    # Validar tabela
+    valid_tables = [
+        "customers", "creditors", "enterprises", "purchase_invoices", 
+        "stock_inventories", "accounts_receivable", "sync_meta",
+        "installment_payments", "income_installments"
+    ]
+    
+    if table_name not in valid_tables:
+        return {
+            "success": False,
+            "message": f"❌ Tabela '{table_name}' não é válida",
+            "error": "INVALID_TABLE",
+            "valid_tables": valid_tables
+        }
+    
+    try:
+        # Construir query sempre usando schema sienge_data
+        schema_client = client.schema(SUPABASE_SCHEMA)
+        query = schema_client.table(table_name).select(columns)
+        
+        # Aplicar filtros
+        if filters:
+            for field, value in filters.items():
+                if isinstance(value, str) and "%" in value:
+                    # Busca com LIKE
+                    query = query.like(field, value)
+                elif isinstance(value, list):
+                    # Busca com IN
+                    query = query.in_(field, value)
+                else:
+                    # Busca exata
+                    query = query.eq(field, value)
+        
+        # Aplicar busca textual se especificada
+        if search_term and search_columns:
+            # Para busca textual, usar OR entre as colunas
+            search_conditions = []
+            for col in search_columns:
+                search_conditions.append(f"{col}.ilike.%{search_term}%")
+            if search_conditions:
+                query = query.or_(",".join(search_conditions))
+        elif search_term:
+            # Busca padrão baseada na tabela
+            default_search_columns = {
+                "customers": ["name", "document", "email"],
+                "creditors": ["name", "document"],
+                "enterprises": ["name", "description", "code"],
+                "purchase_invoices": ["sequential_number", "notes"],
+                "stock_inventories": ["cost_center_id", "resource_id"],
+                "accounts_receivable": ["bill_id", "customer_id"],
+                "installment_payments": ["installment_uid"],
+                "income_installments": []  # Campos numéricos - sem busca textual
+            }
+            
+            search_cols = default_search_columns.get(table_name, ["name"])
+            
+            # Se não há colunas de texto para buscar, tentar busca numérica
+            if not search_cols:
+                # Para tabelas com campos numéricos, tentar converter search_term para número
+                try:
+                    search_num = int(search_term)
+                    # Buscar em campos numéricos comuns
+                    numeric_conditions = []
+                    if table_name == "income_installments":
+                        numeric_conditions = [
+                            f"bill_id.eq.{search_num}",
+                            f"customer_id.eq.{search_num}",
+                            f"amount.eq.{search_num}"
+                        ]
+                    elif table_name == "installment_payments":
+                        numeric_conditions = [
+                            f"installment_uid.eq.{search_num}",
+                            f"amount.eq.{search_num}"
+                        ]
+                    
+                    if numeric_conditions:
+                        query = query.or_(",".join(numeric_conditions))
+                except ValueError:
+                    # Se não é número, não fazer busca
+                    pass
+            else:
+                # Busca textual normal
+                search_conditions = [f"{col}.ilike.%{search_term}%" for col in search_cols]
+                if search_conditions:
+                    query = query.or_(",".join(search_conditions))
+        
+        # Aplicar ordenação
+        if order_by:
+            if " desc" in order_by.lower():
+                field = order_by.replace(" desc", "").replace(" DESC", "")
+                query = query.order(field, desc=True)
+            else:
+                field = order_by.replace(" asc", "").replace(" ASC", "")
+                query = query.order(field)
+        
+        # Aplicar limite
+        limit = min(limit or 100, 1000)
+        query = query.limit(limit)
+        
+        # Executar query
+        result = query.execute()
+        
+        if hasattr(result, 'data'):
+            data = result.data
+        else:
+            data = result
+        
+        return {
+            "success": True,
+            "message": f"✅ Query executada com sucesso na tabela '{table_name}'",
+            "table_name": table_name,
+            "data": data,
+            "count": len(data) if isinstance(data, list) else 1,
+            "query_info": {
+                "columns": columns,
+                "filters": filters,
+                "limit": limit,
+                "order_by": order_by,
+                "search_term": search_term,
+                "search_columns": search_columns
+            }
+        }
+        
+    except Exception as e:
+        logger.error(f"Erro na query Supabase: {e}")
+        return {
+            "success": False,
+            "message": f"❌ Erro ao executar query na tabela '{table_name}'",
+            "error": str(e),
+            "table_name": table_name
+        }
+
+
+# ============ SIMPLE ASYNC CACHE (in-memory, process-local) ============
+# Lightweight helper to improve hit-rate on repeated test queries
+_SIMPLE_CACHE: Dict[str, Dict[str, Any]] = {}
+
+def _simple_cache_set(key: str, value: Dict[str, Any], ttl: int = 60) -> None:
+    expire_at = int(time.time()) + int(ttl)
+    _SIMPLE_CACHE[key] = {"value": value, "expire_at": expire_at}
+
+def _simple_cache_get(key: str) -> Optional[Dict[str, Any]]:
+    item = _SIMPLE_CACHE.get(key)
+    if not item:
+        return None
+    if int(time.time()) > item.get("expire_at", 0):
+        try:
+            del _SIMPLE_CACHE[key]
+        except KeyError:
+            pass
+        return None
+    return item.get("value")
+
+
+async def _fetch_all_paginated(
+    endpoint: str,
+    params: Optional[Dict[str, Any]] = None,
+    page_size: int = 200,
+    max_records: Optional[int] = None,
+    results_key: str = "results",
+    use_bulk: bool = False,
+) -> List[Dict[str, Any]]:
+    """
+    Helper to fetch all pages from a paginated endpoint that uses limit/offset.
+
+    - endpoint: API endpoint path (starting with /)
+    - params: base params (function will add/override limit and offset)
+    - page_size: maximum per request (API typically allows up to 200)
+    - max_records: optional soft limit to stop early
+    - results_key: key in the JSON response where the array is located (default: 'results')
+    - use_bulk: if True expect bulk-data style response where items may be under 'data'
+    """
+    params = dict(params or {})
+    all_items: List[Dict[str, Any]] = []
+    offset = int(params.get("offset", 0) or 0)
+    page_size = min(int(page_size), 200)
+
+    while True:
+        params["limit"] = page_size
+        params["offset"] = offset
+
+        # choose the correct requester
+        requester = make_sienge_bulk_request if use_bulk else make_sienge_request
+        result = await requester("GET", endpoint, params=params)
+
+        if not result.get("success"):
+            # stop and raise or return whatever accumulated
+            return {"success": False, "error": result.get("error"), "message": result.get("message")}
+
+        data = result.get("data")
+
+        if use_bulk:
+            items = data.get("data", []) if isinstance(data, dict) else data
+        else:
+            items = data.get(results_key, []) if isinstance(data, dict) else data
+
+        if not isinstance(items, list):
+            # if API returned single object or unexpected structure, append and stop
+            all_items.append(items)
+            break
+
+        all_items.extend(items)
+
+        # enforce max_records if provided
+        if max_records and len(all_items) >= int(max_records):
+            return all_items[: int(max_records)]
+
+        # if fewer items returned than page_size, we've reached the end
+        if len(items) < page_size:
+            break
+
+        offset += len(items) if len(items) > 0 else page_size
+
+    return all_items
+
+
 @mcp.tool
 def get_auth_info() -> Dict:
     """Retorna informações sobre a configuração de autenticação"""
@@ -2733,4 +2566,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()