@omnizap-system/omnizap 2.6.1 → 2.6.2

package/app/observability/metrics.js

@@ -32,6 +32,8 @@ const METRICS_SERVICE = process.env.METRICS_SERVICE_NAME || process.env.ECOSYSTE
 const HTTP_SLO_TARGET_MS = Math.max(50, parseEnvNumber(process.env.HTTP_SLO_TARGET_MS, 750));
 
 const QUERY_THRESHOLDS_MS = parseThresholds(process.env.DB_QUERY_ALERT_THRESHOLDS, [500, 1000]);
+const ADMIN_ALERT_SEVERITIES = Object.freeze(['critical', 'high', 'medium', 'low', 'unknown']);
+const ADMIN_FEATURE_FLAG_STATES = Object.freeze(['enabled', 'disabled', 'total']);
 
 const registry = new client.Registry();
 let metrics = null;
@@ -375,6 +377,53 @@ const ensureMetrics = () => {
       labelNames: ['outcome'],
       registers: [registry],
     }),
+    adminOverviewUpdatedAtSeconds: new client.Gauge({
+      name: 'omnizap_admin_overview_updated_at_seconds',
+      help: 'Timestamp Unix (s) da ultima atualizacao de snapshot do painel admin',
+      registers: [registry],
+    }),
+    adminOverviewRequestsTotal: new client.Counter({
+      name: 'omnizap_admin_overview_requests_total',
+      help: 'Total de snapshots do painel admin publicados em metricas',
+      labelNames: ['source'],
+      registers: [registry],
+    }),
+    adminCounters: new client.Gauge({
+      name: 'omnizap_admin_counters',
+      help: 'Contadores agregados do painel admin',
+      labelNames: ['counter'],
+      registers: [registry],
+    }),
+    adminDashboardQuick: new client.Gauge({
+      name: 'omnizap_admin_dashboard_quick',
+      help: 'Metricas rapidas do dashboard admin',
+      labelNames: ['metric'],
+      registers: [registry],
+    }),
+    adminSystemHealth: new client.Gauge({
+      name: 'omnizap_admin_system_health',
+      help: 'Indicadores de saude expostos no painel admin',
+      labelNames: ['metric'],
+      registers: [registry],
+    }),
+    adminAlertsTotal: new client.Gauge({
+      name: 'omnizap_admin_alerts_total',
+      help: 'Total de alertas ativos por severidade no painel admin',
+      labelNames: ['severity'],
+      registers: [registry],
+    }),
+    adminFeatureFlagsTotal: new client.Gauge({
+      name: 'omnizap_admin_feature_flags_total',
+      help: 'Distribuicao de feature flags no painel admin',
+      labelNames: ['state'],
+      registers: [registry],
+    }),
+    adminSnapshotItemsTotal: new client.Gauge({
+      name: 'omnizap_admin_snapshot_items_total',
+      help: 'Total de itens por secao no snapshot do painel admin',
+      labelNames: ['section'],
+      registers: [registry],
+    }),
   };
 
   return metrics;
@@ -502,6 +551,93 @@ export const recordMessagesUpsert = ({ durationMs, type, messagesCount, ok }) =>
   }
 };
 
+export const setAdminOverviewSnapshot = ({ overview = null, source = 'admin_overview' } = {}) => {
+  const m = ensureMetrics();
+  if (!m) return;
+  if (!overview || typeof overview !== 'object') return;
+
+  const setGaugeIfFinite = (gauge, labels, value, { clampToZero = false } = {}) => {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric)) return;
+    gauge.set(labels, clampToZero ? Math.max(0, numeric) : numeric);
+  };
+
+  const sourceLabel = normalizeLabel(source, 'admin_overview').slice(0, 32);
+  m.adminOverviewRequestsTotal.inc({ source: sourceLabel });
+
+  const updatedAtMs = Date.parse(String(overview?.updated_at || ''));
+  const updatedAtSeconds = Number.isFinite(updatedAtMs) ? updatedAtMs / 1000 : Date.now() / 1000;
+  m.adminOverviewUpdatedAtSeconds.set(updatedAtSeconds);
+
+  const counters = overview?.counters && typeof overview.counters === 'object' ? overview.counters : {};
+  const counterKeys = ['total_packs_any_status', 'total_stickers_any_status', 'active_google_sessions', 'known_google_users', 'active_bans', 'visit_events_24h', 'visit_events_7d', 'unique_visitors_7d'];
+  for (const key of counterKeys) {
+    setGaugeIfFinite(m.adminCounters, { counter: key }, counters?.[key], { clampToZero: true });
+  }
+
+  const dashboardQuick = overview?.dashboard_quick && typeof overview.dashboard_quick === 'object' ? overview.dashboard_quick : {};
+  const quickKeys = ['bots_online', 'messages_today', 'spam_blocked_today', 'errors_5xx'];
+  for (const key of quickKeys) {
+    setGaugeIfFinite(m.adminDashboardQuick, { metric: key }, dashboardQuick?.[key], { clampToZero: true });
+  }
+
+  const systemHealth = overview?.system_health && typeof overview.system_health === 'object' ? overview.system_health : {};
+  const healthKeys = ['cpu_percent', 'ram_percent', 'http_latency_p95_ms', 'queue_pending', 'db_total_queries', 'db_slow_queries'];
+  for (const key of healthKeys) {
+    setGaugeIfFinite(m.adminSystemHealth, { metric: key }, systemHealth?.[key], { clampToZero: true });
+  }
+
+  const moderationQueue = Array.isArray(overview?.moderation_queue) ? overview.moderation_queue : [];
+  const auditLog = Array.isArray(overview?.audit_log) ? overview.audit_log : [];
+  const users = Array.isArray(overview?.users_sessions?.users) ? overview.users_sessions.users : [];
+  const activeSessions = Array.isArray(overview?.users_sessions?.active_sessions) ? overview.users_sessions.active_sessions : [];
+  const blockedAccounts = Array.isArray(overview?.users_sessions?.blocked_accounts) ? overview.users_sessions.blocked_accounts : [];
+  const alerts = Array.isArray(overview?.alerts) ? overview.alerts : [];
+  const featureFlags = Array.isArray(overview?.feature_flags) ? overview.feature_flags : [];
+
+  m.adminSnapshotItemsTotal.set({ section: 'moderation_queue' }, moderationQueue.length);
+  m.adminSnapshotItemsTotal.set({ section: 'audit_log' }, auditLog.length);
+  m.adminSnapshotItemsTotal.set({ section: 'users' }, users.length);
+  m.adminSnapshotItemsTotal.set({ section: 'active_sessions' }, activeSessions.length);
+  m.adminSnapshotItemsTotal.set({ section: 'blocked_accounts' }, blockedAccounts.length);
+  m.adminSnapshotItemsTotal.set({ section: 'alerts' }, alerts.length);
+  m.adminSnapshotItemsTotal.set({ section: 'feature_flags' }, featureFlags.length);
+
+  const severityCounts = Object.fromEntries(ADMIN_ALERT_SEVERITIES.map((severity) => [severity, 0]));
+  for (const alert of alerts) {
+    const severityRaw = String(alert?.severity || '')
+      .trim()
+      .toLowerCase();
+    const severity = ADMIN_ALERT_SEVERITIES.includes(severityRaw) ? severityRaw : 'unknown';
+    severityCounts[severity] = Number(severityCounts[severity] || 0) + 1;
+  }
+  for (const severity of ADMIN_ALERT_SEVERITIES) {
+    m.adminAlertsTotal.set({ severity }, Number(severityCounts[severity] || 0));
+  }
+
+  let enabledFlags = 0;
+  let disabledFlags = 0;
+  for (const flag of featureFlags) {
+    if (flag?.is_enabled) {
+      enabledFlags += 1;
+    } else {
+      disabledFlags += 1;
+    }
+  }
+  const totalFlags = enabledFlags + disabledFlags;
+  for (const state of ADMIN_FEATURE_FLAG_STATES) {
+    if (state === 'enabled') {
+      m.adminFeatureFlagsTotal.set({ state }, enabledFlags);
+      continue;
+    }
+    if (state === 'disabled') {
+      m.adminFeatureFlagsTotal.set({ state }, disabledFlags);
+      continue;
+    }
+    m.adminFeatureFlagsTotal.set({ state }, totalFlags);
+  }
+};
+
 export const recordRpgPlayerCreated = (value = 1) => {
   const m = ensureMetrics();
   if (!m) return;

package/app/services/ai/commandConfigEnrichmentService.js

@@ -4,9 +4,13 @@ import path from 'node:path';
 import OpenAI from 'openai';
 import { z } from 'zod';
 
+import { toUnixMs as __timeNowMs } from '#time';
 import logger from '#logger';
+import { createGeminiTextService, DEFAULT_GEMINI_MODEL, isGeminiAuthReady } from './geminiService.js';
 
-const DEFAULT_MODEL = 'gpt-4o-mini';
+const DEFAULT_MODEL = DEFAULT_GEMINI_MODEL;
+const DEFAULT_PROVIDER = 'gemini';
+const DEFAULT_GEMINI_AUTH_MODE = 'cli';
 const DEFAULT_TIMEOUT_MS = 25_000;
 const DEFAULT_CONTEXT_MAX_CHARS = 5_200;
 const DEFAULT_AGENT_MAX_CHARS = 2_400;
@@ -28,13 +32,52 @@ const parseEnvFloat = (value, fallback, min, max) => {
   return Math.max(min, Math.min(max, parsed));
 };
 
+const normalizeProvider = (value, fallback = DEFAULT_PROVIDER) => {
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase();
+  if (normalized === 'gemini') return 'gemini';
+  if (normalized === 'openai') return 'openai';
+  return fallback;
+};
+
+const normalizeGeminiAuthMode = (value, fallback = DEFAULT_GEMINI_AUTH_MODE) => {
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase();
+  if (normalized === 'api_key') return 'api_key';
+  if (normalized === 'cli') return 'cli';
+  if (normalized === 'auto') return 'auto';
+  return fallback;
+};
+
+const looksLikeGeminiModel = (value) =>
+  String(value || '')
+    .trim()
+    .toLowerCase()
+    .includes('gemini');
+
+const looksLikeOpenAiModel = (value) => {
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase();
+  if (!normalized) return false;
+  return normalized.startsWith('gpt-') || normalized.startsWith('o1') || normalized.startsWith('o3') || normalized.startsWith('o4') || normalized.startsWith('text-');
+};
+
+const COMMAND_CONFIG_ENRICHMENT_PROVIDER = normalizeProvider(process.env.COMMAND_CONFIG_ENRICHMENT_WORKER_PROVIDER || process.env.AI_HELP_LLM_PROVIDER || DEFAULT_PROVIDER, DEFAULT_PROVIDER);
 const COMMAND_CONFIG_ENRICHMENT_MODEL = String(process.env.COMMAND_CONFIG_ENRICHMENT_WORKER_MODEL || DEFAULT_MODEL).trim() || DEFAULT_MODEL;
+const COMMAND_CONFIG_ENRICHMENT_GEMINI_MODEL = looksLikeGeminiModel(COMMAND_CONFIG_ENRICHMENT_MODEL) ? COMMAND_CONFIG_ENRICHMENT_MODEL : String(process.env.GEMINI_MODEL || DEFAULT_GEMINI_MODEL).trim() || DEFAULT_GEMINI_MODEL;
+const COMMAND_CONFIG_ENRICHMENT_OPENAI_MODEL = looksLikeOpenAiModel(COMMAND_CONFIG_ENRICHMENT_MODEL) ? COMMAND_CONFIG_ENRICHMENT_MODEL : String(process.env.OPENAI_MODEL || 'gpt-5-nano').trim() || 'gpt-5-nano';
 const COMMAND_CONFIG_ENRICHMENT_TIMEOUT_MS = parseEnvInt(process.env.COMMAND_CONFIG_ENRICHMENT_WORKER_TIMEOUT_MS, DEFAULT_TIMEOUT_MS, 5_000, 90_000);
 const COMMAND_CONFIG_ENRICHMENT_CONTEXT_MAX_CHARS = parseEnvInt(process.env.COMMAND_CONFIG_ENRICHMENT_CONTEXT_MAX_CHARS, DEFAULT_CONTEXT_MAX_CHARS, 1_500, 16_000);
 const COMMAND_CONFIG_ENRICHMENT_AGENT_MAX_CHARS = parseEnvInt(process.env.COMMAND_CONFIG_ENRICHMENT_AGENT_MAX_CHARS, DEFAULT_AGENT_MAX_CHARS, 600, 8_000);
 const COMMAND_CONFIG_ENRICHMENT_SOURCE_FILE_MAX_CHARS = parseEnvInt(process.env.COMMAND_CONFIG_ENRICHMENT_SOURCE_FILE_MAX_CHARS, DEFAULT_SOURCE_FILE_MAX_CHARS, 400, 5_000);
 const COMMAND_CONFIG_ENRICHMENT_MAX_SOURCE_FILES = parseEnvInt(process.env.COMMAND_CONFIG_ENRICHMENT_MAX_SOURCE_FILES, DEFAULT_MAX_SOURCE_FILES, 1, 8);
 const COMMAND_CONFIG_ENRICHMENT_BASE_CONFIDENCE = parseEnvFloat(process.env.COMMAND_CONFIG_ENRICHMENT_BASE_CONFIDENCE, 0.55, 0.1, 1);
+const COMMAND_CONFIG_ENRICHMENT_PROVIDER_FAILURE_COOLDOWN_MS = parseEnvInt(process.env.COMMAND_CONFIG_ENRICHMENT_PROVIDER_FAILURE_COOLDOWN_MS, 15 * 60 * 1000, 30_000, 24 * 60 * 60 * 1000);
+const COMMAND_CONFIG_ENRICHMENT_GEMINI_AUTH_MODE = normalizeGeminiAuthMode(process.env.COMMAND_CONFIG_ENRICHMENT_WORKER_GEMINI_AUTH_MODE || process.env.GEMINI_AUTH_MODE || DEFAULT_GEMINI_AUTH_MODE, DEFAULT_GEMINI_AUTH_MODE);
+const COMMAND_CONFIG_ENRICHMENT_GEMINI_CLI_COMMAND = String(process.env.COMMAND_CONFIG_ENRICHMENT_WORKER_GEMINI_CLI_COMMAND || process.env.GEMINI_CLI_COMMAND || 'gemini').trim() || 'gemini';
 
 const AI_ENRICHMENT_OUTPUT_SCHEMA = z
   .object({
@@ -48,6 +91,12 @@ const AI_ENRICHMENT_OUTPUT_SCHEMA = z
   .strict();
 
 let cachedClient = null;
+let cachedGeminiService = null;
+let cachedGeminiServiceKey = '';
+const providerCooldownUntil = {
+  gemini: 0,
+  openai: 0,
+};
 
 const moduleConfigCache = new Map();
 const fileTextCache = new Map();
@@ -105,6 +154,51 @@ const parseJsonSafe = (value) => {
   }
 };
 
+const parseJsonFromModelOutput = (rawOutput) => {
+  const direct = parseJsonSafe(rawOutput);
+  if (direct && typeof direct === 'object') return direct;
+
+  const text = String(rawOutput || '').trim();
+  if (!text) return null;
+
+  const fenceMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (fenceMatch?.[1]) {
+    const fenced = parseJsonSafe(fenceMatch[1]);
+    if (fenced && typeof fenced === 'object') return fenced;
+  }
+
+  const start = text.indexOf('{');
+  const end = text.lastIndexOf('}');
+  if (start >= 0 && end > start) {
+    const sliced = parseJsonSafe(text.slice(start, end + 1));
+    if (sliced && typeof sliced === 'object') return sliced;
+  }
+
+  return null;
+};
+
+const isProviderInCooldown = (provider) => {
+  const now = __timeNowMs();
+  const safeProvider = provider === 'openai' ? 'openai' : 'gemini';
+  return Number(providerCooldownUntil[safeProvider] || 0) > now;
+};
+
+const shouldApplyProviderCooldown = (provider, error) => {
+  const message = normalizeText(error?.message || error);
+  if (!message) return false;
+
+  const hardErrorPatterns = ['modelnotfound', 'does not exist', 'requested entity was not found', 'permission denied', 'unauthorized', 'invalid api key', 'quota', '429'];
+  if (hardErrorPatterns.some((token) => message.includes(token))) return true;
+  return false;
+};
+
+const markProviderCooldown = (provider, error) => {
+  if (!shouldApplyProviderCooldown(provider, error)) return false;
+  const safeProvider = provider === 'openai' ? 'openai' : 'gemini';
+  providerCooldownUntil[safeProvider] = __timeNowMs() + COMMAND_CONFIG_ENRICHMENT_PROVIDER_FAILURE_COOLDOWN_MS;
+  return true;
+};
+
 const uniqueList = (values = [], { maxItems = DEFAULT_MAX_LIST_ITEMS, maxLength = 200, normalizeMode = 'display' } = {}) => {
   const source = Array.isArray(values) ? values : [];
   const output = [];
@@ -175,6 +269,86 @@ const getOpenAIClient = () => {
   return cachedClient;
 };
 
+const isGeminiReady = () =>
+  isGeminiAuthReady({
+    authMode: COMMAND_CONFIG_ENRICHMENT_GEMINI_AUTH_MODE,
+    apiKey: process.env.GEMINI_API_KEY,
+    cliCommand: COMMAND_CONFIG_ENRICHMENT_GEMINI_CLI_COMMAND,
+  });
+
+const isOpenAiReady = () => Boolean(String(process.env.OPENAI_API_KEY || '').trim());
+
+const getGeminiService = () => {
+  if (!isGeminiReady()) return null;
+
+  const serviceKey = `${COMMAND_CONFIG_ENRICHMENT_MODEL}|${COMMAND_CONFIG_ENRICHMENT_TIMEOUT_MS}|${COMMAND_CONFIG_ENRICHMENT_GEMINI_AUTH_MODE}|${COMMAND_CONFIG_ENRICHMENT_GEMINI_CLI_COMMAND}|${Boolean(String(process.env.GEMINI_API_KEY || '').trim())}`;
+  if (!cachedGeminiService || cachedGeminiServiceKey !== serviceKey) {
+    cachedGeminiService = createGeminiTextService({
+      apiKey: process.env.GEMINI_API_KEY,
+      defaultModel: COMMAND_CONFIG_ENRICHMENT_GEMINI_MODEL,
+      timeoutMs: COMMAND_CONFIG_ENRICHMENT_TIMEOUT_MS,
+      authMode: COMMAND_CONFIG_ENRICHMENT_GEMINI_AUTH_MODE,
+      cliCommand: COMMAND_CONFIG_ENRICHMENT_GEMINI_CLI_COMMAND,
+    });
+    cachedGeminiServiceKey = serviceKey;
+  }
+  return cachedGeminiService;
+};
+
+const callGeminiEnrichment = async ({ systemPrompt, contextPayload }) => {
+  const service = getGeminiService();
+  if (!service) return null;
+
+  const response = await service.generateText({
+    instructions: systemPrompt,
+    userPrompt: contextPayload,
+    model: COMMAND_CONFIG_ENRICHMENT_GEMINI_MODEL,
+  });
+
+  const text = String(response?.text || '').trim();
+  if (!text) return null;
+  return {
+    provider: 'gemini',
+    model: String(response?.model || COMMAND_CONFIG_ENRICHMENT_GEMINI_MODEL).trim() || COMMAND_CONFIG_ENRICHMENT_GEMINI_MODEL,
+    outputText: text,
+  };
+};
+
+const callOpenAiEnrichment = async ({ systemPrompt, contextPayload }) => {
+  if (!isOpenAiReady()) return null;
+
+  const client = getOpenAIClient();
+  const completion = await client.chat.completions.create({
+    model: COMMAND_CONFIG_ENRICHMENT_OPENAI_MODEL,
+    response_format: { type: 'json_object' },
+    messages: [
+      {
+        role: 'system',
+        content: systemPrompt,
+      },
+      {
+        role: 'user',
+        content: contextPayload,
+      },
+    ],
+  });
+
+  const message = completion?.choices?.[0]?.message || {};
+  const outputText = extractTextFromAssistantMessage(message);
+  if (!outputText) return null;
+  return {
+    provider: 'openai',
+    model: COMMAND_CONFIG_ENRICHMENT_OPENAI_MODEL,
+    outputText,
+  };
+};
+
+const resolveLlmCallOrder = () => {
+  const primary = normalizeProvider(COMMAND_CONFIG_ENRICHMENT_PROVIDER, DEFAULT_PROVIDER);
+  const fallback = primary === 'gemini' ? 'openai' : 'gemini';
+  return [primary, fallback];
+};
+
 const isFilePathInside = (baseDir, candidatePath) => {
   const normalizedBase = path.resolve(baseDir);
   const normalizedCandidate = path.resolve(candidatePath);
@@ -333,7 +507,7 @@ const buildCommandContextPayload = async ({ learningEvent, toolRecord }) => {
 };
 
 const parseAndSanitizeOutput = (rawJson) => {
-  const parsed = parseJsonSafe(rawJson);
+  const parsed = parseJsonFromModelOutput(rawJson);
   if (!parsed || typeof parsed !== 'object') return null;
 
   const validated = AI_ENRICHMENT_OUTPUT_SCHEMA.safeParse(parsed);
@@ -379,7 +553,7 @@ const buildHeuristicSuggestion = ({ learningEvent, toolRecord }) => {
   };
 };
 
-const isLlmReady = () => Boolean(process.env.OPENAI_API_KEY);
+const isLlmReady = () => isGeminiReady() || isOpenAiReady();
 
 export const generateCommandConfigEnrichmentSuggestion = async ({ learningEvent, toolRecord } = {}) => {
   if (!learningEvent || !toolRecord) return null;
@@ -390,63 +564,71 @@ export const generateCommandConfigEnrichmentSuggestion = async ({ learningEvent,
   }
 
   const contextPayload = await buildCommandContextPayload({ learningEvent, toolRecord });
-  const client = getOpenAIClient();
+  const systemPrompt = buildSystemPrompt();
 
-  let completion = null;
-  try {
-    completion = await client.chat.completions.create({
-      model: COMMAND_CONFIG_ENRICHMENT_MODEL,
-      temperature: 0.15,
-      response_format: { type: 'json_object' },
-      messages: [
-        {
-          role: 'system',
-          content: buildSystemPrompt(),
-        },
-        {
-          role: 'user',
-          content: contextPayload,
-        },
-      ],
-    });
-  } catch (error) {
-    logger.warn('Falha ao gerar enriquecimento de commandConfig com LLM.', {
-      action: 'command_config_enrichment_llm_failed',
-      module: toolRecord?.moduleKey || null,
-      command: toolRecord?.commandName || null,
-      event_id: learningEvent?.id || null,
-      error: error?.message,
-    });
-    return fallbackSuggestion;
-  }
-
-  const message = completion?.choices?.[0]?.message || {};
-  const rawJson = extractTextFromAssistantMessage(message);
-  const parsed = parseAndSanitizeOutput(rawJson);
+  const providerOrder = resolveLlmCallOrder();
+  for (const provider of providerOrder) {
+    if (isProviderInCooldown(provider)) {
+      continue;
+    }
 
-  if (!parsed || !isSuggestionMeaningful(parsed.suggestion)) {
-    return fallbackSuggestion;
+    try {
+      const llmOutput =
+        provider === 'gemini'
+          ? await callGeminiEnrichment({
+              systemPrompt,
+              contextPayload,
+            })
+          : await callOpenAiEnrichment({
+              systemPrompt,
+              contextPayload,
+            });
+
+      if (!llmOutput?.outputText) continue;
+
+      const parsed = parseAndSanitizeOutput(llmOutput.outputText);
+      if (!parsed || !isSuggestionMeaningful(parsed.suggestion)) continue;
+
+      const eventConfidence = clamp01(learningEvent?.confidence);
+      const successSignal = learningEvent?.success ? 0.12 : 0.03;
+      const finalConfidence = clamp01(parsed.modelConfidence * 0.72 + eventConfidence * 0.18 + successSignal);
+
+      return {
+        suggestion: parsed.suggestion,
+        confidence: finalConfidence,
+        source: `llm_${provider}`,
+        modelName: llmOutput.model || COMMAND_CONFIG_ENRICHMENT_MODEL,
+      };
+    } catch (error) {
+      logger.warn('Falha ao gerar enriquecimento de commandConfig com LLM.', {
+        action: 'command_config_enrichment_llm_failed',
+        module: toolRecord?.moduleKey || null,
+        command: toolRecord?.commandName || null,
+        event_id: learningEvent?.id || null,
+        provider,
+        provider_cooldown_applied: markProviderCooldown(provider, error),
+        error: error?.message,
+      });
+    }
   }
 
-  const eventConfidence = clamp01(learningEvent?.confidence);
-  const successSignal = learningEvent?.success ? 0.12 : 0.03;
-  const finalConfidence = clamp01(parsed.modelConfidence * 0.72 + eventConfidence * 0.18 + successSignal);
-
-  return {
-    suggestion: parsed.suggestion,
-    confidence: finalConfidence,
-    source: 'llm',
-    modelName: COMMAND_CONFIG_ENRICHMENT_MODEL,
-  };
+  return fallbackSuggestion;
 };
 
 export const getCommandConfigEnrichmentServiceConfig = () => ({
+  provider: COMMAND_CONFIG_ENRICHMENT_PROVIDER,
   model: COMMAND_CONFIG_ENRICHMENT_MODEL,
+  geminiModel: COMMAND_CONFIG_ENRICHMENT_GEMINI_MODEL,
+  openaiModel: COMMAND_CONFIG_ENRICHMENT_OPENAI_MODEL,
   timeoutMs: COMMAND_CONFIG_ENRICHMENT_TIMEOUT_MS,
   contextMaxChars: COMMAND_CONFIG_ENRICHMENT_CONTEXT_MAX_CHARS,
   agentMaxChars: COMMAND_CONFIG_ENRICHMENT_AGENT_MAX_CHARS,
   sourceFileMaxChars: COMMAND_CONFIG_ENRICHMENT_SOURCE_FILE_MAX_CHARS,
   maxSourceFiles: COMMAND_CONFIG_ENRICHMENT_MAX_SOURCE_FILES,
   baseConfidence: COMMAND_CONFIG_ENRICHMENT_BASE_CONFIDENCE,
+  geminiAuthMode: COMMAND_CONFIG_ENRICHMENT_GEMINI_AUTH_MODE,
+  hasGeminiAuth: isGeminiReady(),
+  hasOpenAiApiKey: isOpenAiReady(),
   hasApiKey: isLlmReady(),
+  providerFailureCooldownMs: COMMAND_CONFIG_ENRICHMENT_PROVIDER_FAILURE_COOLDOWN_MS,
 });

package/app/services/ai/geminiService.js

@@ -1,5 +1,13 @@
+import { execFile, spawnSync } from 'node:child_process';
+import { promisify } from 'node:util';
+
 const DEFAULT_GEMINI_API_BASE_URL = 'https://generativelanguage.googleapis.com/v1beta';
-export const DEFAULT_GEMINI_MODEL = 'gemini-1.5-flash';
+export const DEFAULT_GEMINI_MODEL = 'gemini-2.5-flash';
+const DEFAULT_GEMINI_AUTH_MODE = 'auto';
+const DEFAULT_GEMINI_CLI_COMMAND = 'gemini';
+
+const execFileAsync = promisify(execFile);
+const cliAvailabilityCache = new Map();
 
 const normalizeModelName = (value, fallback = DEFAULT_GEMINI_MODEL) => {
   const raw = String(value || '').trim();
@@ -13,6 +21,64 @@ const toPositiveInt = (value, fallback, min = 1) => {
   return parsed;
 };
 
+const normalizeAuthMode = (value, fallback = DEFAULT_GEMINI_AUTH_MODE) => {
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase();
+  if (normalized === 'api_key') return 'api_key';
+  if (normalized === 'cli') return 'cli';
+  if (normalized === 'auto') return 'auto';
+  return fallback;
+};
+
+const normalizeCliCommand = (value) => {
+  const command = String(value || DEFAULT_GEMINI_CLI_COMMAND).trim();
+  return command || DEFAULT_GEMINI_CLI_COMMAND;
+};
+
+const parseBooleanEnv = (value, fallback = false) => {
+  if (value === undefined || value === null || value === '') return fallback;
+  const normalized = String(value).trim().toLowerCase();
+  if (['1', 'true', 'yes', 'sim', 'on'].includes(normalized)) return true;
+  if (['0', 'false', 'no', 'nao', 'não', 'off'].includes(normalized)) return false;
+  return fallback;
+};
+
+const isGeminiCliAvailable = (cliCommand = DEFAULT_GEMINI_CLI_COMMAND) => {
+  const safeCliCommand = normalizeCliCommand(cliCommand);
+  if (cliAvailabilityCache.has(safeCliCommand)) {
+    return cliAvailabilityCache.get(safeCliCommand);
+  }
+
+  let available = false;
+  try {
+    const result = spawnSync(safeCliCommand, ['--version'], {
+      stdio: 'ignore',
+      shell: false,
+    });
+    available = result?.status === 0;
+  } catch {
+    available = false;
+  }
+
+  cliAvailabilityCache.set(safeCliCommand, available);
+  return available;
+};
+
+const sanitizeCliOutput = (value) =>
+  String(value || '')
+    .replaceAll('\0', '')
+    .replace(/\r\n/g, '\n')
+    .trim();
+
+const buildCliPrompt = ({ instructions = '', userPrompt = '' } = {}) => {
+  const safePrompt = normalizeOutboundText(userPrompt);
+  const safeInstructions = normalizeOutboundText(instructions);
+  if (!safeInstructions) return safePrompt;
+  if (!safePrompt) return safeInstructions;
+  return `${safeInstructions}\n\n---\n\n${safePrompt}`;
+};
+
 const parseErrorMessage = (payload, status) => {
   const explicit = String(payload?.error?.message || '').trim();
   if (explicit) return explicit;
@@ -35,14 +101,25 @@ const normalizeOutboundText = (value) =>
     .join('')
     .trim();
 
-export const createGeminiTextService = ({ apiKey = process.env.GEMINI_API_KEY, defaultModel = process.env.GEMINI_MODEL || DEFAULT_GEMINI_MODEL, timeoutMs = 25_000, apiBaseUrl = process.env.GEMINI_API_BASE_URL || DEFAULT_GEMINI_API_BASE_URL } = {}) => {
+export const isGeminiAuthReady = ({ authMode = process.env.GEMINI_AUTH_MODE || DEFAULT_GEMINI_AUTH_MODE, apiKey = process.env.GEMINI_API_KEY, cliCommand = process.env.GEMINI_CLI_COMMAND || DEFAULT_GEMINI_CLI_COMMAND } = {}) => {
+  const mode = normalizeAuthMode(authMode, DEFAULT_GEMINI_AUTH_MODE);
   const safeApiKey = String(apiKey || '').trim();
-  if (!safeApiKey) return null;
+  const useCliByEnv = parseBooleanEnv(process.env.GEMINI_USE_CLI_AUTH, false);
+  const modeWithLegacy = mode === 'auto' && useCliByEnv ? 'cli' : mode;
 
-  if (typeof globalThis.fetch !== 'function') {
-    throw new Error('createGeminiTextService: global fetch indisponivel no runtime atual.');
-  }
+  if (modeWithLegacy === 'api_key') return Boolean(safeApiKey);
+  if (modeWithLegacy === 'cli') return isGeminiCliAvailable(cliCommand);
+  if (safeApiKey) return true;
+  return isGeminiCliAvailable(cliCommand);
+};
 
+export const createGeminiTextService = ({ apiKey = process.env.GEMINI_API_KEY, defaultModel = process.env.GEMINI_MODEL || DEFAULT_GEMINI_MODEL, timeoutMs = 25_000, apiBaseUrl = process.env.GEMINI_API_BASE_URL || DEFAULT_GEMINI_API_BASE_URL, authMode = process.env.GEMINI_AUTH_MODE || DEFAULT_GEMINI_AUTH_MODE, cliCommand = process.env.GEMINI_CLI_COMMAND || DEFAULT_GEMINI_CLI_COMMAND, execFileAsyncImpl = execFileAsync, isCliAvailableImpl = isGeminiCliAvailable } = {}) => {
+  const safeApiKey = String(apiKey || '').trim();
+  const safeAuthMode = normalizeAuthMode(authMode, DEFAULT_GEMINI_AUTH_MODE);
+  const useCliByEnv = parseBooleanEnv(process.env.GEMINI_USE_CLI_AUTH, false);
+  const normalizedAuthMode = safeAuthMode === 'auto' && useCliByEnv ? 'cli' : safeAuthMode;
+  const selectedTransport = normalizedAuthMode === 'api_key' ? 'api_key' : normalizedAuthMode === 'cli' ? 'cli' : safeApiKey ? 'api_key' : 'cli';
+  const safeCliCommand = normalizeCliCommand(cliCommand);
   const safeBaseUrl =
     String(apiBaseUrl || DEFAULT_GEMINI_API_BASE_URL)
       .trim()
@@ -50,7 +127,16 @@ export const createGeminiTextService = ({ apiKey = process.env.GEMINI_API_KEY, d
   const safeTimeoutMs = Math.max(1_000, toPositiveInt(timeoutMs, 25_000, 1_000));
   const resolvedDefaultModel = normalizeModelName(defaultModel, DEFAULT_GEMINI_MODEL);
 
-  const generateText = async ({ instructions = '', userPrompt = '', model = resolvedDefaultModel } = {}) => {
+  if (selectedTransport === 'api_key') {
+    if (!safeApiKey) return null;
+    if (typeof globalThis.fetch !== 'function') {
+      throw new Error('createGeminiTextService: global fetch indisponivel no runtime atual.');
+    }
+  } else if (!isCliAvailableImpl(safeCliCommand)) {
+    return null;
+  }
+
+  const generateTextViaApiKey = async ({ instructions = '', userPrompt = '', model = resolvedDefaultModel } = {}) => {
     const safePrompt = normalizeOutboundText(userPrompt);
     if (!safePrompt) return { text: '', model: normalizeModelName(model, resolvedDefaultModel) };
 
@@ -109,8 +195,46 @@ export const createGeminiTextService = ({ apiKey = process.env.GEMINI_API_KEY, d
     }
   };
 
+  const generateTextViaCli = async ({ instructions = '', userPrompt = '', model = resolvedDefaultModel } = {}) => {
+    const prompt = buildCliPrompt({ instructions, userPrompt });
+    const modelName = normalizeModelName(model, resolvedDefaultModel);
+    if (!prompt) return { text: '', model: modelName };
+
+    const args = ['-m', modelName, '-p', prompt, '--output-format', 'text'];
+    try {
+      const result = await execFileAsyncImpl(safeCliCommand, args, {
+        timeout: safeTimeoutMs,
+        maxBuffer: 2 * 1024 * 1024,
+        env: process.env,
+      });
+      const text = sanitizeCliOutput(result?.stdout);
+      if (!text) {
+        const stderrText = sanitizeCliOutput(result?.stderr);
+        throw new Error(stderrText || 'Gemini CLI retornou resposta vazia.');
+      }
+      return {
+        text,
+        model: modelName,
+      };
+    } catch (error) {
+      const stderrText = sanitizeCliOutput(error?.stderr);
+      const stdoutText = sanitizeCliOutput(error?.stdout);
+      const baseMessage = String(error?.message || '').trim();
+      const finalMessage = stderrText || stdoutText || baseMessage || 'Falha ao executar Gemini CLI.';
+      throw new Error(finalMessage);
+    }
+  };
+
+  const generateText = async ({ instructions = '', userPrompt = '', model = resolvedDefaultModel } = {}) => {
+    if (selectedTransport === 'api_key') {
+      return generateTextViaApiKey({ instructions, userPrompt, model });
+    }
+    return generateTextViaCli({ instructions, userPrompt, model });
+  };
+
   return {
     defaultModel: resolvedDefaultModel,
+    transport: selectedTransport,
     generateText,
   };
 };