metheus-governance-mcp-cli 0.2.84 → 0.2.86

package/README.md

@@ -241,7 +241,7 @@ Behavior:
   - `Sonnet 4.6r` -> `sonnet`
   - `Haiku 4.5` -> `haiku`
   - `Opus 4.6` -> `opus`
-  - `Gemini 3.1 Pro` -> `gemini-2.5-pro`
+  - `gemini-3.1-pro` -> `auto-gemini-3`
 - if one server bot name maps to multiple server roles, `bot edit` keeps the Telegram env entry bound to the server identity and lets you review the local `role_profiles` for each detected role instead of forcing one role/profile UUID choice up front.
 - In the normal Telegram edit path, the CLI keeps or re-resolves the server bot binding automatically. It no longer asks you to pick `approval / worker / review / monitor` or a server bot UUID first.
 - `bot set-default` without flags starts a guided numbered flow: provider -> bot entry -> confirm default change.
@@ -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

@@ -1473,12 +1473,12 @@ function suggestedAIModelsForClient(clientName) {
       { value: "Haiku 4.5", label: "Haiku 4.5", description: "display label; runs as haiku" },
       { value: "Opus 4.6", label: "Opus 4.6", description: "display label; runs as opus" },
     ];
-  }
-  if (normalizedClient === "gemini") {
-    return [
-      { value: "Gemini 3.1 Pro", label: "Gemini 3.1 Pro", description: "display label; runs as gemini-2.5-pro" },
-    ];
-  }
+    }
+    if (normalizedClient === "gemini") {
+      return [
+        { value: "gemini-3.1-pro", label: "gemini-3.1-pro", description: "display label; runs as auto-gemini-3" },
+      ];
+    }
   if (normalizedClient === "sample") {
     return [
       { value: "sample", label: "sample", description: "sample adapter model placeholder" },

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: [
     {
@@ -45,9 +54,16 @@ const LOCAL_AI_MODEL_MAPPINGS = {
   ],
   gemini: [
     {
-      display: "Gemini 3.1 Pro",
-      execution: "gemini-2.5-pro",
-      aliases: ["gemini 3.1 pro", "gemini-3.1-pro", "gemini-2.5-pro", "gemini 2.5 pro"],
+      display: "gemini-3.1-pro",
+      execution: "auto-gemini-3",
+      aliases: [
+        "gemini-3.1-pro",
+        "gemini 3.1 pro",
+        "Gemini 3.1 Pro",
+        "gemini-3.1-pro-preview",
+        "auto-gemini-3",
+        "pro",
+      ],
     },
   ],
   sample: [],
@@ -73,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) {
@@ -323,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");
@@ -385,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) {
@@ -601,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 {
@@ -243,13 +244,29 @@ export async function runSelftestBotCommands(push, deps) {
         && resolveLocalAIExecutionModel("claude", "Sonnet 4.6r") === "sonnet"
         && resolveLocalAIExecutionModel("claude", "Haiku 4.5") === "haiku"
         && resolveLocalAIExecutionModel("claude", "Opus 4.6") === "opus"
-        && resolveLocalAIExecutionModel("gemini", "Gemini 3.1 Pro") === "gemini-2.5-pro",
+        && resolveLocalAIExecutionModel("gemini", "gemini-3.1-pro") === "auto-gemini-3",
       [
         `gpt54=${resolveLocalAIExecutionModel("codex", "gpt-5.4")}`,
         `gpt53codex=${resolveLocalAIExecutionModel("codex", "gpt-5.3-codex")}`,
         `spark=${resolveLocalAIExecutionModel("codex", "gpt-5.3-codex-spark")}`,
         `claude=${resolveLocalAIExecutionModel("claude", "Sonnet 4.6r")}`,
-        `gemini=${resolveLocalAIExecutionModel("gemini", "Gemini 3.1 Pro")}`,
+        `gemini=${resolveLocalAIExecutionModel("gemini", "gemini-3.1-pro")}`,
+      ].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(" "),
     );
 
@@ -393,7 +410,7 @@ export async function runSelftestBotCommands(push, deps) {
             "3", // select role to edit: approval
             "2", // approval: edit settings
             "4", // approval AI client: gemini
-            "2", // approval AI model: Gemini 3.1 Pro
+            "2", // approval AI model: gemini-3.1-pro
             "4", // approval permission: danger_full_access
             "4", // approval reasoning: high
             "n", // stop editing roles
@@ -416,7 +433,7 @@ export async function runSelftestBotCommands(push, deps) {
           && String(safeObject(safeObject(groupedRunnerConfig.role_profiles || {}).worker).permission_mode || "") === "danger_full_access"
           && String(safeObject(safeObject(groupedRunnerConfig.role_profiles || {}).worker).reasoning_effort || "") === "high"
           && String(safeObject(safeObject(groupedRunnerConfig.role_profiles || {}).approval).client || "") === "gemini"
-          && String(safeObject(safeObject(groupedRunnerConfig.role_profiles || {}).approval).model || "") === "Gemini 3.1 Pro",
+          && String(safeObject(safeObject(groupedRunnerConfig.role_profiles || {}).approval).model || "") === "gemini-3.1-pro",
         `worker=${JSON.stringify(safeObject(safeObject(groupedRunnerConfig.role_profiles || {}).worker))} approval=${JSON.stringify(safeObject(safeObject(groupedRunnerConfig.role_profiles || {}).approval))}`,
       );
 
@@ -525,7 +542,7 @@ export async function runSelftestBotCommands(push, deps) {
         "2", // change AI client
         "4", // gemini
         "2", // change AI model
-        "2", // gemini model: Gemini 3.1 Pro
+        "2", // gemini model: gemini-3.1-pro
         "2", // change permission mode
         "3", // workspace_write
         "2", // change reasoning effort
@@ -544,7 +561,7 @@ export async function runSelftestBotCommands(push, deps) {
     push(
       "bot_edit_guided_prompts_update_ai_binding_fields",
       String(guidedState.TELEGRAM_BOT_MONITORSELFTESTBOT_AI_CLIENT || "") === "gemini"
-        && String(guidedState.TELEGRAM_BOT_MONITORSELFTESTBOT_AI_MODEL || "") === "Gemini 3.1 Pro"
+        && String(guidedState.TELEGRAM_BOT_MONITORSELFTESTBOT_AI_MODEL || "") === "gemini-3.1-pro"
         && String(guidedState.TELEGRAM_BOT_MONITORSELFTESTBOT_AI_PERMISSION_MODE || "") === "workspace_write"
         && String(guidedState.TELEGRAM_BOT_MONITORSELFTESTBOT_AI_REASONING_EFFORT || "") === "medium",
       `client=${String(guidedState.TELEGRAM_BOT_MONITORSELFTESTBOT_AI_CLIENT || "")} model=${String(guidedState.TELEGRAM_BOT_MONITORSELFTESTBOT_AI_MODEL || "")}`,

package/package.json

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