metheus-governance-mcp-cli 0.2.85 → 0.2.87

package/README.md

@@ -410,7 +410,8 @@ Recommended role mapping:
 Role profile note:
 - Claude maps `reasoning_effort` to `--effort`.
 - Codex maps `reasoning_effort` to `-c model_reasoning_effort="..."`.
-- Gemini CLI still has no dedicated effort flag, so the runner keeps the value in env/prompt context for policy parity.
+- Gemini applies `reasoning_effort` by injecting a temporary `~/.gemini/settings.json` override for the invocation.
+- For Gemini 3 models, `low -> thinkingLevel LOW`, `medium -> THINKING_LEVEL_UNSPECIFIED` (Gemini default), and `high -> thinkingLevel HIGH`.
 
 Trigger policy fields:
 - `mentions_only`: in groups, react only when the bot is mentioned or when a message replies to the bot

package/cli.mjs

@@ -11,6 +11,7 @@ import https from "node:https";
 import {
   DEFAULT_LOCAL_AI_CLIENT,
   resolveLocalAIExecutionModel,
+  resolveGeminiReasoningConfig,
   SUPPORTED_LOCAL_AI_CLIENTS,
   normalizeLocalAIClientName,
   normalizeLocalAIPermissionMode,
@@ -3358,6 +3359,7 @@ function buildBotCommandDeps() {
     normalizeLocalAIClientName,
     normalizeLocalAIPermissionMode,
     normalizeLocalAIReasoningEffort,
+    resolveGeminiReasoningConfig,
     supportedLocalAIClients: SUPPORTED_LOCAL_AI_CLIENTS,
     summarizeProviderSupport,
     loadProviderEnvConfig,
@@ -5209,6 +5211,7 @@ TELEGRAM_BOT_REVIEW_TOKEN=review-token
     cliPath: fileURLToPath(import.meta.url),
     parseSimpleEnvText,
     resolveLocalAIExecutionModel,
+    resolveGeminiReasoningConfig,
   });
 
   const payload = buildSelftestPayload(checks);

package/lib/bot-commands.mjs

@@ -633,6 +633,23 @@ function displayLocalAIClientName(clientName) {
   return String(clientName || "").trim();
 }
 
+function formatRuntimeReasoningField(clientName, reasoningEffort) {
+  const normalizedClient = String(clientName || "").trim().toLowerCase();
+  const normalizedEffort = String(reasoningEffort || "").trim();
+  if (!normalizedEffort) {
+    if (normalizedClient === "claude") return "thinking=(blank)";
+    if (normalizedClient === "gemini") return "thinking=(blank)";
+    return "reasoning=(blank)";
+  }
+  if (normalizedClient === "claude") {
+    return `thinking=${normalizedEffort} (Claude effort)`;
+  }
+  if (normalizedClient === "gemini") {
+    return `thinking=${normalizedEffort} (Gemini level)`;
+  }
+  return `reasoning=${normalizedEffort}`;
+}
+
 function telegramEntryDisplayDescription(entry) {
   const current = safeObject(entry);
   const detail = [
@@ -948,7 +965,7 @@ function formatRoleProfileOutputLine(profile) {
     current.client ? `client=${displayLocalAIClientName(current.client)}` : "client=(blank)",
     current.model ? `model=${current.model}` : "model=(blank)",
     current.permissionMode ? `permission=${current.permissionMode}` : "permission=(blank)",
-    current.reasoningEffort ? `reasoning=${current.reasoningEffort}` : "reasoning=(blank)",
+    formatRuntimeReasoningField(current.client, current.reasoningEffort),
   ].join(" | ");
 }
 

package/lib/local-ai-adapters.mjs

@@ -8,6 +8,15 @@ export const DEFAULT_LOCAL_AI_CLIENT = "codex";
 
 const SUPPORTED_PERMISSION_MODES = ["read_only", "workspace_write", "danger_full_access"];
 const SUPPORTED_REASONING_EFFORTS = ["low", "medium", "high"];
+const GEMINI_HOME_SYNC_FILES = [
+  "google_accounts.json",
+  "oauth_creds.json",
+  "installation_id",
+  "state.json",
+  "trustedFolders.json",
+  "projects.json",
+  "settings.json",
+];
 const LOCAL_AI_MODEL_MAPPINGS = {
   codex: [
     {
@@ -80,6 +89,10 @@ function ensureArray(value) {
   return Array.isArray(value) ? value : [];
 }
 
+function safeObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+
 function intFromRawAllowZero(rawValue, fallback = 0) {
   const parsed = Number.parseInt(String(rawValue ?? "").trim(), 10);
   if (!Number.isFinite(parsed) || parsed < 0) {
@@ -330,6 +343,122 @@ function buildGeminiArgs({ promptText, model, permissionMode }) {
   return args;
 }
 
+function isGemini3ExecutionModel(model) {
+  const normalizedModel = normalizeModelAliasText(model);
+  return normalizedModel === "auto-gemini-3" || normalizedModel.startsWith("gemini-3");
+}
+
+function readJsonFileIfExists(filePath) {
+  if (!filePath || !fs.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function copyFileIfExists(sourcePath, targetPath) {
+  if (!sourcePath || !targetPath || !fs.existsSync(sourcePath)) {
+    return;
+  }
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+  fs.copyFileSync(sourcePath, targetPath);
+}
+
+function buildGeminiThinkingConfig(model, reasoningEffort) {
+  const normalizedReasoningEffort = normalizeLocalAIReasoningEffort(reasoningEffort, "");
+  if (!normalizedReasoningEffort) {
+    return null;
+  }
+  if (isGemini3ExecutionModel(model)) {
+    if (normalizedReasoningEffort === "low") {
+      return { thinkingLevel: "LOW" };
+    }
+    if (normalizedReasoningEffort === "high") {
+      return { thinkingLevel: "HIGH" };
+    }
+    return { thinkingLevel: "THINKING_LEVEL_UNSPECIFIED" };
+  }
+  const thinkingBudgetMap = {
+    low: 0,
+    medium: 4096,
+    high: 8192,
+  };
+  return {
+    thinkingBudget: thinkingBudgetMap[normalizedReasoningEffort] ?? thinkingBudgetMap.medium,
+  };
+}
+
+export function resolveGeminiReasoningConfig(rawModelValue = "", reasoningEffort = "medium") {
+  const executionModel = resolveLocalAIExecutionModel("gemini", rawModelValue);
+  const thinkingConfig = buildGeminiThinkingConfig(executionModel, reasoningEffort);
+  if (!thinkingConfig) {
+    return null;
+  }
+  return {
+    model: executionModel,
+    thinkingConfig,
+  };
+}
+
+function buildGeminiSettingsOverride(existingSettings, model, reasoningEffort) {
+  const resolved = resolveGeminiReasoningConfig(model, reasoningEffort);
+  if (!resolved) {
+    return safeObject(existingSettings);
+  }
+  const baseSettings = safeObject(existingSettings);
+  const baseModelConfigs = safeObject(baseSettings.modelConfigs);
+  const nextOverrides = ensureArray(baseModelConfigs.overrides).slice();
+  nextOverrides.push({
+    match: { model: resolved.model },
+    modelConfig: {
+      generateContentConfig: {
+        thinkingConfig: resolved.thinkingConfig,
+      },
+    },
+  });
+  return {
+    ...baseSettings,
+    modelConfigs: {
+      ...baseModelConfigs,
+      overrides: nextOverrides,
+    },
+  };
+}
+
+function prepareGeminiRuntimeEnv({ model, reasoningEffort, env }) {
+  const sourceHome = String(env?.GEMINI_CLI_HOME || os.homedir() || "").trim();
+  const sourceGeminiDir = sourceHome ? path.join(sourceHome, ".gemini") : "";
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-gemini-home-"));
+  const tempGeminiDir = path.join(tempHome, ".gemini");
+  fs.mkdirSync(tempGeminiDir, { recursive: true });
+  for (const fileName of GEMINI_HOME_SYNC_FILES) {
+    copyFileIfExists(
+      sourceGeminiDir ? path.join(sourceGeminiDir, fileName) : "",
+      path.join(tempGeminiDir, fileName),
+    );
+  }
+  const mergedSettings = buildGeminiSettingsOverride(
+    readJsonFileIfExists(path.join(tempGeminiDir, "settings.json")),
+    model,
+    reasoningEffort,
+  );
+  fs.writeFileSync(path.join(tempGeminiDir, "settings.json"), `${JSON.stringify(mergedSettings, null, 2)}\n`, "utf8");
+  return {
+    env: {
+      ...env,
+      GEMINI_CLI_HOME: tempHome,
+    },
+    cleanup() {
+      if (fs.existsSync(tempHome)) {
+        fs.rmSync(tempHome, { recursive: true, force: true });
+      }
+    },
+  };
+}
+
 function runCodexAdapter({ promptText, workspaceDir, model, permissionMode, reasoningEffort, env }) {
   const outputPath = path.join(os.tmpdir(), `metheus-runner-codex-${Date.now()}-${Math.random().toString(36).slice(2)}.txt`);
   const codexCommand = resolveLocalCliCommand("codex");
@@ -392,29 +521,34 @@ function runClaudeAdapter({ promptText, workspaceDir, model, permissionMode, rea
   return normalizeCliOutput(result.stdout);
 }
 
-function runGeminiAdapter({ promptText, workspaceDir, model, permissionMode, env }) {
+function runGeminiAdapter({ promptText, workspaceDir, model, permissionMode, reasoningEffort, env }) {
   const geminiCommand = resolveLocalCliCommand("gemini");
-  const result = spawnCli(
-    geminiCommand,
-    buildGeminiArgs({
-      promptText,
-      model,
-      permissionMode,
-    }),
-    {
-      cwd: workspaceDir,
-      encoding: "utf8",
-      env,
-      maxBuffer: 8 * 1024 * 1024,
-    },
-  );
-  if (result.error) {
-    throw new Error(String(result.error?.message || result.error));
-  }
-  if (result.status !== 0) {
-    throw new Error(String(result.stderr || result.stdout || `gemini exited with status ${result.status}`));
+  const runtime = prepareGeminiRuntimeEnv({ model, reasoningEffort, env });
+  try {
+    const result = spawnCli(
+      geminiCommand,
+      buildGeminiArgs({
+        promptText,
+        model,
+        permissionMode,
+      }),
+      {
+        cwd: workspaceDir,
+        encoding: "utf8",
+        env: runtime.env,
+        maxBuffer: 8 * 1024 * 1024,
+      },
+    );
+    if (result.error) {
+      throw new Error(String(result.error?.message || result.error));
+    }
+    if (result.status !== 0) {
+      throw new Error(String(result.stderr || result.stdout || `gemini exited with status ${result.status}`));
+    }
+    return normalizeCliOutput(result.stdout);
+  } finally {
+    runtime.cleanup();
   }
-  return normalizeCliOutput(result.stdout);
 }
 
 function runSampleAdapter(payload) {
@@ -608,6 +742,7 @@ export function runLocalAIClient({
       workspaceDir: resolvedWorkspaceDir,
       model: resolvedExecutionModel,
       permissionMode: normalizedPermissionMode,
+      reasoningEffort: normalizedReasoningEffort,
       env: nextEnv,
     });
   }

package/lib/selftest-bot-commands.mjs

@@ -229,6 +229,7 @@ export async function runSelftestBotCommands(push, deps) {
   const cliPath = String(requireDependency(deps, "cliPath") || "").trim();
   const parseSimpleEnvText = requireDependency(deps, "parseSimpleEnvText");
   const resolveLocalAIExecutionModel = requireDependency(deps, "resolveLocalAIExecutionModel");
+  const resolveGeminiReasoningConfig = requireDependency(deps, "resolveGeminiReasoningConfig");
   let tempHome = "";
   let mock = null;
   try {
@@ -253,6 +254,22 @@ export async function runSelftestBotCommands(push, deps) {
       ].join(" "),
     );
 
+    const geminiLowReasoning = resolveGeminiReasoningConfig("gemini-3.1-pro", "low");
+    const geminiMediumReasoning = resolveGeminiReasoningConfig("gemini-3.1-pro", "medium");
+    const geminiHighReasoning = resolveGeminiReasoningConfig("gemini-3.1-pro", "high");
+    push(
+      "gemini_reasoning_effort_maps_to_runtime_settings_override",
+      String(geminiLowReasoning?.model || "") === "auto-gemini-3"
+        && String(safeObject(geminiLowReasoning?.thinkingConfig).thinkingLevel || "") === "LOW"
+        && String(safeObject(geminiMediumReasoning?.thinkingConfig).thinkingLevel || "") === "THINKING_LEVEL_UNSPECIFIED"
+        && String(safeObject(geminiHighReasoning?.thinkingConfig).thinkingLevel || "") === "HIGH",
+      [
+        `low=${JSON.stringify(geminiLowReasoning?.thinkingConfig || {})}`,
+        `medium=${JSON.stringify(geminiMediumReasoning?.thinkingConfig || {})}`,
+        `high=${JSON.stringify(geminiHighReasoning?.thinkingConfig || {})}`,
+      ].join(" "),
+    );
+
     tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "metheus-bot-selftest-"));
     mock = await createMockServer().listen();
     const env = buildSpawnEnv(tempHome);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metheus-governance-mcp-cli",
-  "version": "0.2.85",
+  "version": "0.2.87",
   "description": "Metheus Governance MCP CLI (setup + stdio proxy)",
   "type": "module",
   "files": [