thumbgate 1.27.18 → 1.27.19

package/scripts/gemini-embedding-policy.js

@@ -122,7 +122,7 @@ function resolveGeminiEmbeddingConfig(env = process.env) {
 
   return {
     enabled,
-    provider: enabled ? 'gemini' : 'local',
+    provider: provider === 'coreai' ? 'coreai' : (enabled ? 'gemini' : 'local'),
     model: String(env.THUMBGATE_GEMINI_EMBED_MODEL || GEMINI_EMBEDDING_2_MODEL).trim() || GEMINI_EMBEDDING_2_MODEL,
     apiKey,
     apiBaseUrl: trimTrailingSlashes(env.THUMBGATE_GEMINI_API_BASE_URL || 'https://generativelanguage.googleapis.com/v1beta'),
@@ -171,6 +171,7 @@ function buildGeminiEmbeddingRolloutPlan(args = {}) {
     },
     rolloutSteps: [
       'Keep local embeddings as the default offline path.',
+      'For Apple Silicon developers, route local queries through Core AI (AOT compiled models) to bypass CPU overhead.',
       'Enable Gemini Embedding 2 only when a Gemini API key is present.',
       'Use task-specific query/document prefixes at index and retrieval time.',
       'Start at 768 dimensions, then benchmark 1536 only if recall misses show up.',

package/scripts/hook-runtime.js

@@ -7,6 +7,7 @@ const {
   publishedCliAvailable,
 } = require('./mcp-config');
 const { publishedCliShellCommand } = require('./published-cli');
+const { shimInstalled, shimPath } = require('./install-shim');
 
 const PKG_ROOT = path.join(__dirname, '..');
 const featureSupportCache = new Map();
@@ -33,34 +34,39 @@ function publishedHookCommandsAvailable(version) {
   return available;
 }
 
-function resolveCliBaseCommand() {
+function resolveCliCommand(subcommand) {
+  // Source checkout: always use direct node command for development
+  if (isSourceCheckout(PKG_ROOT)) {
+    return `node ${shellQuote(path.join(PKG_ROOT, 'bin', 'cli.js'))} ${subcommand}`;
+  }
+  // Prefer stable shim — always resolves @latest, survives version bumps
+  if (shimInstalled()) {
+    return `${shellQuote(shimPath())} ${subcommand}`;
+  }
   const version = packageVersion();
   if (publishedHookCommandsAvailable(version)) {
-    return publishedCliShellCommand(version);
-  }
-  if (isSourceCheckout(PKG_ROOT)) {
-    return `node ${shellQuote(path.join(PKG_ROOT, 'bin', 'cli.js'))}`;
+    return publishedCliShellCommand(version, [subcommand]);
   }
-  return publishedCliShellCommand(version);
+  return publishedCliShellCommand(version, [subcommand]);
 }
 
-function resolveCodexCliBaseCommand() {
+function resolveCodexCliCommand(subcommand) {
   const version = packageVersion();
   if (publishedHookCommandsAvailable(version)) {
-    return publishedCliShellCommand('latest', [], { preferInstalled: false });
+    return publishedCliShellCommand('latest', [subcommand]);
   }
   if (isSourceCheckout(PKG_ROOT)) {
-    return `node ${shellQuote(path.join(PKG_ROOT, 'bin', 'cli.js'))}`;
+    return `node ${shellQuote(path.join(PKG_ROOT, 'bin', 'cli.js'))} ${subcommand}`;
   }
-  return publishedCliShellCommand('latest', [], { preferInstalled: false });
+  return publishedCliShellCommand('latest', [subcommand]);
 }
 
 function buildPortableHookCommand(subcommand) {
-  return `${resolveCliBaseCommand()} ${subcommand}`;
+  return resolveCliCommand(subcommand);
 }
 
 function buildCodexPortableHookCommand(subcommand) {
-  return `${resolveCodexCliBaseCommand()} ${subcommand}`;
+  return resolveCodexCliCommand(subcommand);
 }
 
 function preToolHookCommand() {
@@ -115,8 +121,8 @@ module.exports = {
   packageVersion,
   publishedHookCommandsAvailable,
   preToolHookCommand,
-  resolveCodexCliBaseCommand,
-  resolveCliBaseCommand,
+  resolveCodexCliCommand,
+  resolveCliCommand,
   sessionStartHookCommand,
   statuslineCommand,
   userPromptHookCommand,

package/scripts/hook-thumbgate-cache-updater.js

@@ -6,11 +6,27 @@
  * Also used directly by the CLI to refresh statusline counters after feedback capture.
  */
 
-const fs = require('fs');
-const path = require('path');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
 const { resolveFeedbackDir } = require('./feedback-paths');
+const {
+  getAggregateStatuslineCachePath,
+  shouldAggregateFeedback,
+} = require('./feedback-aggregate');
 
 function getCachePath() {
+  const explicitFeedbackDir = process.env.THUMBGATE_FEEDBACK_DIR;
+  if (shouldAggregateFeedback() && explicitFeedbackDir) {
+    try {
+      if (path.resolve(explicitFeedbackDir).startsWith(path.resolve(os.tmpdir()) + path.sep)) {
+        return path.join(resolveFeedbackDir(), 'statusline_cache.json');
+      }
+    } catch {
+      return path.join(resolveFeedbackDir(), 'statusline_cache.json');
+    }
+  }
+  if (shouldAggregateFeedback()) return getAggregateStatuslineCachePath();
   return path.join(resolveFeedbackDir(), 'statusline_cache.json');
 }
 

package/scripts/hybrid-feedback-context.js

@@ -18,6 +18,11 @@ const fs = require('fs');
 const path = require('path');
 const { resolveFeedbackDir } = require('./feedback-paths');
 const { readJsonl } = require('./fs-utils');
+const {
+  TRANSPORT_WORDS,
+  sanitizeFeedbackText,
+  transportWordsOnly,
+} = require('./feedback-sanitizer');
 
 // ---------------------------------------------------------------------------
 // Paths
@@ -51,6 +56,7 @@ const STOPWORDS = new Set([
   'has', 'had', 'not', 'but', 'they', 'you', 'can', 'will', 'all', 'any',
   'one', 'its', 'our', 'also', 'more', 'very', 'just', 'into', 'been',
   'bash', 'edit', 'write', 'tool', 'hook', 'clear',
+  ...TRANSPORT_WORDS,
 ]);
 
 const NEG = new Set([
@@ -74,7 +80,7 @@ const HYBRID_JSONL_READ_LIMIT = 400;
  */
 function normalize(text) {
   if (!text || typeof text !== 'string') return '';
-  return text
+  return sanitizeFeedbackText(text)
     .replace(/\/Users\/[^\s/]+/g, '/Users/redacted')
     .replace(/:\d{4,5}\b/g, ':PORT')
     .toLowerCase()
@@ -97,7 +103,9 @@ function stripFeedbackPrefix(text) {
  * Compose normalize + stripFeedbackPrefix.
  */
 function normalizePatternText(text) {
-  return normalize(stripFeedbackPrefix(text));
+  const normalized = normalize(stripFeedbackPrefix(text));
+  if (transportWordsOnly(normalized)) return '';
+  return normalized;
 }
 
 /**
@@ -125,6 +133,104 @@ function classify(entry) {
   return 'neutral';
 }
 
+function isHookPromptEnvelope(context) {
+  if (!context || typeof context !== 'string') return false;
+  try {
+    const parsed = JSON.parse(context);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return false;
+    return Boolean(
+      parsed.prompt &&
+      (
+        parsed.hookEventName ||
+        parsed.hook_event_name ||
+        parsed.workspaceRoot ||
+        parsed.workspace_root ||
+        parsed.session_id ||
+        parsed.sessionId ||
+        parsed.transcript_path ||
+        parsed.transcriptPath
+      )
+    );
+  } catch (_) {
+    return false;
+  }
+}
+
+function patternContext(entry) {
+  const context = entry && entry.context ? String(entry.context) : '';
+  if (!context) return '';
+  const hasExplicitFeedback = Boolean(
+    entry.whatWentWrong ||
+    entry.what_went_wrong ||
+    entry.whatToChange ||
+    entry.what_to_change ||
+    entry.failureType ||
+    (Array.isArray(entry.tags) && entry.tags.length > 0) ||
+    entry.structuredRule
+  );
+  if (isHookPromptEnvelope(context) && !hasExplicitFeedback) return '';
+  if (isHookPromptEnvelope(context) && hasExplicitFeedback) {
+    return '';
+  }
+  return context;
+}
+
+/**
+ * Check if the feedback entry is an automated enforcement log (e.g. from gates engine)
+ * rather than real developer/user feedback.
+ */
+function isAutomatedFeedback(entry) {
+  const tags = entry.tags || [];
+  if (tags.includes('auto-capture') || tags.includes('gates-engine') || tags.includes('audit-trail')) {
+    return true;
+  }
+  const context = String(entry.context || entry.whatWentWrong || '').toLowerCase();
+  return context.includes('gate "') || context.includes('blocked tool') || context.includes('warned tool');
+}
+
+
+function isHookPromptEnvelope(context) {
+  if (!context || typeof context !== 'string') return false;
+  try {
+    const parsed = JSON.parse(context);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return false;
+    return Boolean(
+      parsed.prompt &&
+      (
+        parsed.hookEventName ||
+        parsed.hook_event_name ||
+        parsed.workspaceRoot ||
+        parsed.workspace_root ||
+        parsed.session_id ||
+        parsed.sessionId ||
+        parsed.transcript_path ||
+        parsed.transcriptPath
+      )
+    );
+  } catch (_) {
+    return false;
+  }
+}
+
+function patternContext(entry) {
+  const context = entry && entry.context ? String(entry.context) : '';
+  if (!context) return '';
+  const hasExplicitFeedback = Boolean(
+    entry.whatWentWrong ||
+    entry.what_went_wrong ||
+    entry.whatToChange ||
+    entry.what_to_change ||
+    entry.failureType ||
+    (Array.isArray(entry.tags) && entry.tags.length > 0) ||
+    entry.structuredRule
+  );
+  if (isHookPromptEnvelope(context) && !hasExplicitFeedback) return '';
+  if (isHookPromptEnvelope(context) && hasExplicitFeedback) {
+    return '';
+  }
+  return context;
+}
+
 /**
  * Extract ms from a timestamp value. Returns 0 on failure.
  */
@@ -212,13 +318,15 @@ function buildHybridState(opts) {
     if (cls === 'positive') positive++;
     if (cls === 'negative') {
       negative++;
-      // Track tool-level negative counts
-      const toolName = inferToolName(entry.toolName || entry.tool_name || 'unknown', entry.context || '');
-      toolNegatives[toolName] = (toolNegatives[toolName] || 0) + 1;
+      // Track tool-level negative counts (exclude automated gate logs)
+      if (!isAutomatedFeedback(entry)) {
+        const toolName = inferToolName(entry.toolName || entry.tool_name || 'unknown', entry.context || '');
+        toolNegatives[toolName] = (toolNegatives[toolName] || 0) + 1;
+      }
 
       // Build pattern from context / whatWentWrong / what_went_wrong
       const rawText = [
-        entry.context || '',
+        patternContext(entry),
         entry.whatWentWrong || entry.what_went_wrong || '',
         entry.whatToChange || entry.what_to_change || '',
         entry.failureType || '',
@@ -254,11 +362,13 @@ function buildHybridState(opts) {
 
   // Process attributed feedback separately to track attributed tool counts
   for (const entry of attributedEntries) {
+    if (classify(entry) !== 'negative') continue; // skip pruned/positive
+    if (isAutomatedFeedback(entry)) continue; // skip automated gate blocks
     const toolName = inferToolName(entry.toolName || entry.tool_name || entry.attributed_tool || 'unknown', entry.context || '');
     toolNegativesAttributed[toolName] = (toolNegativesAttributed[toolName] || 0) + 1;
 
     const rawText = [
-      entry.context || '',
+      patternContext(entry),
       entry.whatWentWrong || entry.what_went_wrong || '',
       ...(Array.isArray(entry.tags) ? entry.tags : []),
       ...(entry.richContext && Array.isArray(entry.richContext.filePaths) ? entry.richContext.filePaths : []),
@@ -620,12 +730,36 @@ function evaluatePretool(toolName, toolInput, opts) {
 
   // Slow path: build live state (also used when compiled guards are stale)
   const state = buildHybridState({
+    feedbackDir: o.feedbackDir,
     feedbackLogPath: o.feedbackLogPath,
     attributedFeedbackPath: o.attributedFeedbackPath,
   });
   return evaluatePretoolFromState(state, toolName, toolInput);
 }
 
+// Claw-style agent support (high-ROI for EnterpriseClaw / OpenShell agents from Automation Anywhere / Nvidia)
+// Extends hybrid context for claw_action_type (file, screen, dynamic-tool, orchestration), agent_identity, hybrid_route.
+// Use in evaluatePretool calls from claw-aware MCP/hooks: pass {clawContext: {actionType: 'dynamic-tool-creation', agentId: '...', route: 'local/cloud'}} in opts.
+function evaluateClawPretool(toolName, toolInput, clawContext, opts) {
+  const o = opts || {};
+  const claw = clawContext || {};
+  // Merge claw metadata into toolInput for gate evaluation (so templates like block-dynamic-tool-creation can match)
+  const enrichedInput = {
+    ...(typeof toolInput === 'object' ? toolInput : { raw: toolInput }),
+    _claw: {
+      actionType: claw.actionType || 'unknown',
+      agentId: claw.agentId || 'unknown',
+      hybridRoute: claw.hybridRoute || 'unknown',
+      screenInteraction: !!claw.screenInteraction,
+      fileAccess: !!claw.fileAccess,
+    }
+  };
+  const result = evaluatePretool(toolName, JSON.stringify(enrichedInput), o);
+  // Tag result with claw metadata for logging/feedback
+  result.clawContext = claw;
+  return result;
+}
+
 // ---------------------------------------------------------------------------
 // CLI main()
 // ---------------------------------------------------------------------------
@@ -674,6 +808,7 @@ function main() {
 module.exports = {
   buildHybridState,
   evaluatePretool,
+  evaluateClawPretool,
   compileGuardArtifact,
   writeGuardArtifact,
   readGuardArtifact,

package/scripts/lesson-inference.js

@@ -18,6 +18,7 @@ const fs = require('fs');
 const path = require('path');
 const { resolveFeedbackDir } = require('./feedback-paths');
 const { ensureParentDir, readJsonl } = require('./fs-utils');
+const { redactSecretsDeep } = require('./secret-redaction');
 const {
   buildStableId,
   extractFilePaths,
@@ -137,15 +138,19 @@ function createLesson({ feedbackId, signal, inferredLesson, triggerMessage, prio
   // Stable link: dashboard deep-link to this lesson
   lesson.link = `${getLessonBaseUrl()}/lessons#${lesson.id}`;
 
+  // Redact secrets before persisting — lesson text is derived from conversation content that may
+  // have captured a pasted credential. See scripts/secret-redaction.js.
+  const redactedLesson = redactSecretsDeep(lesson);
+
   const lessonsPath = getLessonsPath();
   ensureParentDir(lessonsPath);
-  fs.appendFileSync(lessonsPath, JSON.stringify(lesson) + '\n');
+  fs.appendFileSync(lessonsPath, JSON.stringify(redactedLesson) + '\n');
 
   // Update recent lesson for statusbar
   const recentPath = getRecentLessonPath();
-  fs.writeFileSync(recentPath, JSON.stringify(lesson, null, 2) + '\n');
+  fs.writeFileSync(recentPath, JSON.stringify(redactedLesson, null, 2) + '\n');
 
-  return lesson;
+  return redactedLesson;
 }
 
 /**

package/scripts/lesson-search.js

@@ -2,6 +2,7 @@
 
 const path = require('node:path');
 const { readJSONL, getFeedbackPaths } = require('./feedback-loop');
+const { buildMemoryLifecycleView, scoreHybridMemoryMatch } = require('./agent-memory-lifecycle');
 const { loadOptionalModule } = require('./private-core-boundary');
 
 const HIGH_RISK_TAGS = new Set([
@@ -411,7 +412,8 @@ function scoreLesson(queryText, memory, parsed, sourceFeedback) {
   const score = jaccardSimilarity(queryTokens, lessonTokens)
     + substringBoost(queryText, lessonText)
     + recencyScore(memory.timestamp)
-    + (memory.category === 'error' ? 0.05 : 0);
+    + (memory.category === 'error' ? 0.05 : 0)
+    + Math.min(0.2, scoreHybridMemoryMatch(queryText, memory).score * 0.1);
 
   return {
     score,
@@ -427,6 +429,7 @@ function buildLessonResult(memory, sourceFeedback, options = {}) {
   const { score, matchedTokens } = scoreLesson(options.query || '', memory, parsed, sourceFeedback);
   const harnessRecommendations = buildHarnessRecommendations(memory, parsed, sourceFeedback, ruleMatches, gateMatches);
   const lifecycle = buildLifecycle(memory, parsed, sourceFeedback, ruleMatches, gateMatches, harnessRecommendations);
+  const memoryLifecycle = buildMemoryLifecycleView(memory, { query: options.query || '' });
 
   return {
     id: memory.id,
@@ -452,6 +455,7 @@ function buildLessonResult(memory, sourceFeedback, options = {}) {
     systemResponse: {
       promotedToMemory: true,
       lifecycle,
+      memoryLifecycle,
       diagnosis: memory.diagnosis || null,
       sourceFeedback: sourceFeedback
         ? {
@@ -589,6 +593,14 @@ function tryFts5Search(query, options) {
         tags: row.tags,
         importance: row.importance,
         timestamp: row.timestamp,
+        memoryLifecycle: buildMemoryLifecycleView({
+          title: row.context,
+          content: [row.whatWentWrong, row.whatToChange, row.whatWorked].filter(Boolean).join('\n'),
+          domain: row.domain,
+          tags: row.tags,
+          importance: row.importance,
+          timestamp: row.timestamp,
+        }, { query: query || '' }),
       })),
       backend: 'sqlite-fts5',
     };
@@ -618,6 +630,10 @@ function formatLessonSearchResults(payload) {
   payload.results.forEach((result, index) => {
     lines.push(`${index + 1}. ${result.title}`);
     lines.push(`   Category: ${result.category} | Tags: ${result.tags.join(', ') || 'none'} | Score: ${result.score}`);
+    if (result.systemResponse.memoryLifecycle) {
+      const memoryLifecycle = result.systemResponse.memoryLifecycle;
+      lines.push(`   Memory: scope=${memoryLifecycle.scope} | decay=${memoryLifecycle.decay.state} | hybrid=${memoryLifecycle.retrievalHints.hybridScore}`);
+    }
     if (result.lesson.summary) {
       lines.push(`   Lesson: ${result.lesson.summary}`);
     }

package/scripts/license.js

@@ -23,15 +23,17 @@ function isValidKey(key) {
 }
 
 function verifyLicense(options = {}) {
-  const envKey = [
-    process.env.THUMBGATE_API_KEY,
-    process.env.THUMBGATE_PRO_KEY,
+  // Only ThumbGate's own env vars are license candidates — scanning foreign
+  // *_API_KEY / *_PRO_KEY vars would treat another vendor's secret as a
+  // license key. The result object never carries the raw key value.
+  const envEntry = [
+    ['THUMBGATE_API_KEY', process.env.THUMBGATE_API_KEY],
+    ['THUMBGATE_PRO_KEY', process.env.THUMBGATE_PRO_KEY],
     ...Object.entries(process.env)
-      .filter(([name]) => /(?:_API_KEY|_PRO_KEY)$/.test(name))
-      .map(([, value]) => value),
-  ].find((value) => isValidKey(value));
-  if (isValidKey(envKey)) {
-    return { valid: true, source: 'env', key: envKey };
+      .filter(([name]) => name.startsWith('THUMBGATE_') && /(?:_API_KEY|_PRO_KEY)$/.test(name)),
+  ].find(([, value]) => isValidKey(value));
+  if (envEntry) {
+    return { valid: true, source: 'env', envVar: envEntry[0] };
   }
 
   const licensePath = getLicensePath(options.homeDir);
@@ -42,7 +44,6 @@ function verifyLicense(options = {}) {
         return {
           valid: true,
           source: 'file',
-          key: data.key,
           activatedAt: data.activatedAt,
           path: licensePath,
         };
@@ -80,7 +81,6 @@ module.exports = {
   verifyLicense,
   isProLicensed,
   activateLicense,
-  generateLicenseKey,
   isValidKey,
   VALID_PREFIXES,
   LICENSE_PATH,

package/scripts/llm-client.js

@@ -11,20 +11,23 @@ const MODELS = {
 const DEFAULT_MODEL = MODELS.FAST;
 const DEFAULT_MAX_TOKENS = 1024;
 const DEFAULT_CACHE_TTL = '5m';
+const DEFAULT_ZAI_BASE_URL = 'https://api.z.ai/api/paas/v4';
+const DEFAULT_ZAI_MODEL = 'glm-5.2-flash';
 
-let _client = null;
+let _anthropicClient = null;
+let _geminiClient = null;
 
 function isAvailable() {
   return Boolean(process.env.ANTHROPIC_API_KEY);
 }
 
 function getClient() {
-  if (_client) return _client;
+  if (_anthropicClient) return _anthropicClient;
   if (!isAvailable()) return null;
   try {
     const Anthropic = require('@anthropic-ai/sdk');
-    _client = new Anthropic();
-    return _client;
+    _anthropicClient = new Anthropic();
+    return _anthropicClient;
   } catch {
     return null;
   }
@@ -138,7 +141,144 @@ function parseClaudeJson(text) {
   }
 }
 
+function getZaiApiKey(env = process.env) {
+  return env.ZAI_API_KEY || env.THUMBGATE_ZAI_API_KEY || '';
+}
+
+function getZaiBaseUrl(env = process.env) {
+  return env.ZAI_BASE_URL || env.THUMBGATE_ZAI_BASE_URL || DEFAULT_ZAI_BASE_URL;
+}
+
+function getZaiModel(env = process.env) {
+  return env.ZAI_API_MODEL || env.THUMBGATE_ZAI_MODEL || DEFAULT_ZAI_MODEL;
+}
+
+async function callZaiInternal(options = {}, env = process.env) {
+  const apiKey = getZaiApiKey(env);
+  if (!apiKey || typeof fetch !== 'function') return null;
+
+  const messages = Array.isArray(options.messages) && options.messages.length > 0
+    ? options.messages
+    : [
+      ...(options.systemPrompt ? [{ role: 'system', content: options.systemPrompt }] : []),
+      { role: 'user', content: options.userPrompt || '' },
+    ];
+
+  try {
+    const response = await fetch(`${getZaiBaseUrl(env).replace(/\/$/, '')}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model: options.model || getZaiModel(env),
+        messages,
+        max_tokens: options.maxTokens || DEFAULT_MAX_TOKENS,
+        temperature: Number.isFinite(options.temperature) ? options.temperature : 0,
+      }),
+    });
+
+    if (!response.ok) return null;
+    const json = await response.json();
+    return {
+      text: stripCodeFences(json?.choices?.[0]?.message?.content || ''),
+      usage: json?.usage || null,
+      stopReason: json?.choices?.[0]?.finish_reason || null,
+      id: json?.id || null,
+      model: json?.model || options.model || getZaiModel(env),
+    };
+  } catch {
+    return null;
+  }
+}
+
+async function callGeminiInternal(options = {}) {
+  const env = process.env;
+  const { detectInferenceBackend } = require('./local-model-profile');
+  const providerMode = detectInferenceBackend(env).providerMode;
+
+  try {
+    const { GoogleGenAI } = require('@google/genai');
+    if (!_geminiClient) {
+      if (providerMode === 'vertex') {
+        _geminiClient = new GoogleGenAI({
+          enterprise: true,
+          project: env.VERTEX_PROJECT_ID || 'ai-revenue28-webhook',
+          location: env.VERTEX_LOCATION || 'us-central1',
+        });
+      } else {
+        _geminiClient = new GoogleGenAI({
+          apiKey: env.GEMINI_API_KEY,
+        });
+      }
+    }
+
+    const contents = convertMessagesToGemini(options.messages, options.userPrompt);
+    const config = {};
+    if (options.systemPrompt) {
+      config.systemInstruction = options.systemPrompt;
+    }
+    if (Number.isFinite(options.temperature)) {
+      config.temperature = options.temperature;
+    }
+    if (options.maxTokens) {
+      config.maxOutputTokens = options.maxTokens;
+    }
+
+    const response = await runStep('llm.callGemini', {
+      retries: 2,
+      logger: (msg) => console.warn(msg),
+    }, async () => _geminiClient.models.generateContent({
+      model: options.model,
+      contents,
+      config,
+    }));
+
+    return {
+      text: response.text || '',
+      usage: response.usageMetadata ? {
+        input_tokens: response.usageMetadata.promptTokenCount,
+        output_tokens: response.usageMetadata.candidatesTokenCount,
+      } : null,
+      stopReason: response.candidates?.[0]?.finishReason || null,
+      id: null,
+      model: options.model,
+    };
+  } catch (err) {
+    console.error('Gemini/Vertex AI execution error:', err);
+    return null;
+  }
+}
+
+function convertMessagesToGemini(messages, userPrompt) {
+  const list = Array.isArray(messages) && messages.length > 0
+    ? messages
+    : [{ role: 'user', content: userPrompt }];
+
+  return list.map((msg) => {
+    const role = msg.role === 'assistant' ? 'model' : 'user';
+    let text = '';
+    if (typeof msg.content === 'string') {
+      text = msg.content;
+    } else if (Array.isArray(msg.content)) {
+      text = msg.content.map((c) => c.text || '').join('');
+    } else if (msg.content && typeof msg.content === 'object') {
+      text = msg.content.text || JSON.stringify(msg.content);
+    }
+    return {
+      role,
+      parts: [{ text }],
+    };
+  });
+}
+
 async function callClaudeInternal(options = {}) {
+  const modelName = options.model || '';
+  if (modelName.startsWith('gemini') || modelName.startsWith('vertex')) {
+    return callGeminiInternal(options);
+  }
+
   const client = getClient();
   if (!client) return null;
 
@@ -193,10 +333,35 @@ async function callClaudeJson(options = {}) {
   return parsed;
 }
 
+async function callZaiJson(options = {}) {
+  const result = await callZaiInternal(options);
+  if (!result) return null;
+
+  const parsed = parseClaudeJson(result.text);
+  if (parsed === null) return null;
+
+  if (options.returnMetadata) {
+    return {
+      parsed,
+      text: result.text,
+      usage: result.usage,
+      stopReason: result.stopReason,
+      id: result.id,
+      model: result.model,
+    };
+  }
+
+  return parsed;
+}
+
 module.exports = {
   isAvailable,
   callClaude,
   callClaudeJson,
+  callZaiJson,
+  getZaiApiKey,
+  getZaiBaseUrl,
+  getZaiModel,
   stripCodeFences,
   parseClaudeJson,
   normalizeCacheOptions,