coding-tool-x 3.8.4 → 3.8.6

package/src/platforms/drivers/gemini/native-logs.js

@@ -0,0 +1,180 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { NATIVE_PATHS } = require('../../../config/paths');
+const {
+  normalizeCost,
+  normalizeUsage,
+  usageFieldPaths,
+  createSelectiveJsonLineParser,
+  readJsonLines,
+  walkFiles,
+  createScannedFileCursor,
+  createIncrementalJsonlCursor
+} = require('../native-log-utils');
+const { calculateUsageCost } = require('../../../server/services/usage-log-utils');
+
+const MAX_WHOLE_JSON_BYTES = 16 * 1024 * 1024;
+const MIN_WHOLE_JSON_PARSE_INTERVAL_MS = 15 * 1000;
+
+const GEMINI_SELECTED_FIELDS = [
+  '$set.sessionId', '$set.provider', '$set.model', '$set.lastUpdated',
+  'id', 'messageId', 'uuid', 'model', 'timestamp', 'createdAt', 'provider', 'cost', 'channelId', 'channel',
+  'tokens', 'usage',
+  'message.id', 'message.messageId', 'message.uuid', 'message.model', 'message.timestamp',
+  'message.createdAt', 'message.provider', 'message.cost', 'message.channelId', 'message.channel',
+  'message.tokens', 'message.usage',
+  ...usageFieldPaths('tokens'),
+  ...usageFieldPaths('usage'),
+  ...usageFieldPaths('message.tokens'),
+  ...usageFieldPaths('message.usage')
+];
+
+function parseSession(filePath, fsImpl) {
+  let content;
+  try { content = fsImpl.readFileSync(filePath, 'utf8').trim(); } catch (_) { return []; }
+  if (!content) return [];
+  let session;
+  try {
+    session = JSON.parse(content);
+  } catch (_) {
+    const records = readJsonLines(filePath, fsImpl);
+    const state = {};
+    const messages = [];
+    for (const record of records) {
+      if (record.$set && typeof record.$set === 'object') Object.assign(state, record.$set);
+      if (record.type || record.tokens || record.usage) messages.push(record);
+    }
+    session = { ...state, messages };
+  }
+  const messages = Array.isArray(session?.messages) ? session.messages : [];
+  return messages.flatMap(message => {
+    const usage = message.tokens || message.usage;
+    if (!usage || typeof usage !== 'object') return [];
+    const messageId = message.id || message.messageId || message.uuid || crypto.createHash('sha1')
+      .update(JSON.stringify(message))
+      .digest('hex');
+    return [{
+      id: `${path.basename(filePath)}:${messageId}`,
+      source: 'gemini',
+      sessionId: session.sessionId || path.basename(filePath),
+      timestamp: message.timestamp || message.createdAt || session.lastUpdated,
+      provider: message.provider || session.provider || '',
+      model: message.model || session.model || '',
+      tokens: normalizeUsage(usage),
+      cost: normalizeCost(message.cost ?? usage.cost)
+        || calculateUsageCost('gemini', message.model || session.model || '', normalizeUsage(usage)),
+      channelId: message.channelId,
+      channel: message.channel
+    }];
+  });
+}
+
+function parseGeminiJsonlLine(filePath, record, state) {
+  if (record?.$set && typeof record.$set === 'object') {
+    Object.assign(state.metadata, record.$set);
+  }
+  const message = record?.message && typeof record.message === 'object' ? record.message : record;
+  const usage = message?.tokens || message?.usage;
+  if (!usage || typeof usage !== 'object') return null;
+  const messageId = message.id || message.messageId || message.uuid
+    || record?.id || record?.messageId || record?.uuid || `line-${state.entryIndex}`;
+  const model = message.model || state.metadata.model || '';
+  const sessionId = state.metadata.sessionId || path.basename(filePath);
+  return {
+    id: `${path.basename(filePath)}:${messageId}`,
+    source: 'gemini',
+    sessionId,
+    timestamp: message.timestamp || message.createdAt || state.metadata.lastUpdated,
+    provider: message.provider || state.metadata.provider || '',
+    model,
+    tokens: normalizeUsage(usage),
+    cost: normalizeCost(message.cost ?? usage.cost)
+      || calculateUsageCost('gemini', model, normalizeUsage(usage)),
+    channelId: message.channelId,
+    channel: message.channel
+  };
+}
+
+function createDriver({ nativeRoot, pathContext, fsImpl = fs } = {}) {
+  const resolvedNativeRoot = pathContext?.customized
+    ? (pathContext.native?.tmp || nativeRoot || NATIVE_PATHS.gemini.tmp)
+    : (nativeRoot || NATIVE_PATHS.gemini.tmp);
+  return {
+    platform: 'gemini',
+    capability: 'nativeLogs',
+    createNativeLogCursor({ fs: cursorFs = fsImpl, skipInitialParse = false, onDiagnostic } = {}) {
+      const jsonlFiles = () => walkFiles(resolvedNativeRoot, name => /^session-.*\.jsonl$/.test(name), cursorFs);
+      const jsonFiles = () => walkFiles(resolvedNativeRoot, name => /^session-.*\.json$/.test(name), cursorFs);
+      const jsonlCursor = createIncrementalJsonlCursor({
+        scanFiles: jsonlFiles,
+        createFileState: () => ({ metadata: {} }),
+        parseLine: parseGeminiJsonlLine,
+        fsImpl: cursorFs,
+        skipInitialParse,
+        createLongLineParser: () => createSelectiveJsonLineParser(GEMINI_SELECTED_FIELDS),
+        onDiagnostic,
+        onError: (error, filePath) => {
+          console.warn('[Gemini Native Logs] Failed to read changed JSONL events:', filePath, error.message);
+        }
+      });
+      let lastWholeJsonParse = new Map();
+      let oversizeWarned = new Set();
+      let initializedWholeJsonFiles = new Set();
+      const jsonCursor = createScannedFileCursor({
+        scanFiles: jsonFiles,
+        parseFile: filePath => {
+          return parseSession(filePath, cursorFs);
+        },
+        shouldParseFile: (filePath, stat, { isInitialRead, skipInitialParse }) => {
+          if (stat.size > MAX_WHOLE_JSON_BYTES) {
+            if (!oversizeWarned.has(filePath)) {
+              oversizeWarned.add(filePath);
+              console.warn(`[Gemini Native Logs] Skipping oversized JSON session (${stat.size} bytes): ${filePath}`);
+            }
+            return false;
+          }
+          if (skipInitialParse) {
+            return true;
+          }
+          if (isInitialRead || !initializedWholeJsonFiles.has(filePath)) {
+            initializedWholeJsonFiles.add(filePath);
+            lastWholeJsonParse.set(filePath, Date.now());
+            return true;
+          }
+          const now = Date.now();
+          const allowed = now - (lastWholeJsonParse.get(filePath) || 0) >= MIN_WHOLE_JSON_PARSE_INTERVAL_MS;
+          if (allowed) lastWholeJsonParse.set(filePath, now);
+          return allowed;
+        },
+        normalizeEvent: event => event,
+        fsImpl: cursorFs,
+        skipInitialParse
+      });
+      return {
+        initialize() { jsonlCursor.initialize(); jsonCursor.initialize(); },
+        readNewEvents() { return [...jsonlCursor.readNewEvents(), ...jsonCursor.readNewEvents()]; },
+        read() { return this.readNewEvents(); },
+        reset() {
+          jsonlCursor.reset();
+          jsonCursor.reset();
+          lastWholeJsonParse = new Map();
+          oversizeWarned = new Set();
+          initializedWholeJsonFiles = new Set();
+        },
+        close() {
+          jsonlCursor.close();
+          jsonCursor.close();
+          lastWholeJsonParse.clear();
+          oversizeWarned.clear();
+          initializedWholeJsonFiles.clear();
+        }
+      };
+    },
+    createCursor(options) { return this.createNativeLogCursor(options); }
+  };
+}
+
+module.exports = { createDriver };

package/src/platforms/drivers/gemini/project-config.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const mcpFormat = require('../../../shared/mcp-format');
+const {
+  createProjectAdapter,
+  createJsonMcpHandlers
+} = require('../../../shared/project-config');
+
+function createAdapter({ manifest, fsImpl } = {}) {
+  const relativePath = manifest?.projectResources?.mcp?.path;
+  const mcpHandlers = createJsonMcpHandlers({
+    relativePath,
+    format: manifest?.projectResources?.mcp?.format || 'gemini-json',
+    toNative: mcpFormat.extractServerSpec,
+    fromNative: value => ({ ...value }),
+    fsImpl
+  });
+  return createProjectAdapter({ manifest, fsImpl, mcpHandlers });
+}
+
+module.exports = { createAdapter };

package/src/platforms/drivers/gemini/projects.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const { createProjectsDriver } = require('../../../shared/driver-factories/projects');
+
+function createDriver(context = {}) {
+  return createProjectsDriver({
+    ...context,
+    platform: 'gemini',
+    servicePath: './gemini/sessions-implementation',
+    localServicePath: '../../platforms/drivers/gemini/sessions-implementation',
+    availabilityCheck: () => {
+      const config = context.requireImpl
+        ? context.requireImpl('./gemini/config')
+        : require('./config');
+      config.configure?.({ pathContext: context.pathContext });
+      return config.isGeminiInstalled();
+    },
+    onSuccess: operation => {
+      if (['saveProjectOrder', 'createProject', 'deleteProject'].includes(operation)) {
+        context.sessionHistoryIndex?.invalidateSource('gemini');
+      }
+    }
+  });
+}
+
+module.exports = { createDriver };

package/src/platforms/drivers/gemini/prompts.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const { createPromptDriver } = require('../../../shared/driver-factories/prompts');
+
+function createDriver(context = {}) {
+  return createPromptDriver({ ...context, platform: 'gemini' });
+}
+
+module.exports = { createDriver };

package/src/{server/gemini-proxy-server.js → platforms/drivers/gemini/proxy-implementation.js}

@@ -2,28 +2,18 @@ const express = require('express');
 const httpProxy = require('http-proxy');
 const http = require('http');
 const chalk = require('chalk');
-const { broadcastLog, broadcastSchedulerState } = require('./websocket-server');
-const { allocateChannel, releaseChannel, getSchedulerState } = require('./services/channel-scheduler');
-const { recordSuccess, recordFailure } = require('./services/channel-health');
-const { loadConfig } = require('../config/loader');
-const DEFAULT_CONFIG = require('../config/default');
-const { resolveModelPricing, calculateTokenCost } = require('./utils/pricing');
-const { recordRequest: recordGeminiRequest } = require('./services/gemini-statistics-service');
-const { saveProxyStartTime, clearProxyStartTime, getProxyStartTime, getProxyRuntime } = require('./services/proxy-runtime');
-const { createDecodedStream } = require('./services/response-decoder');
-const { getEffectiveApiKey } = require('./services/gemini-channels');
-const { persistProxyRequestSnapshot } = require('./services/request-logger');
-const { publishUsageLog, publishFailureLog } = require('./services/proxy-log-helper');
-const { redirectModel: redirectModelBase, resolveTargetUrl } = require('./services/base/proxy-utils');
+const { broadcastSchedulerState } = require('../../../server/websocket-server');
+const { allocateChannel, releaseChannel, getSchedulerState } = require('../../../server/services/channel-scheduler');
+const { recordSuccess, recordFailure } = require('../../../server/services/channel-health');
+const { loadConfig } = require('../../../config/loader');
+const { saveProxyStartTime, clearProxyStartTime, getProxyStartTime, getProxyRuntime } = require('../../../server/services/proxy-runtime');
 const {
-  parseSSEUsage,
-  parseNonStreamingUsage,
-  splitSSEEvents,
-  parseSSEEventText,
-  mergeUsageIntoTokenData,
-  createTokenData
-} = require('./services/base/response-usage-parser');
-const { attachServerShutdownHandling, expediteServerShutdown } = require('./services/server-shutdown');
+  getEffectiveApiKey,
+  getGeminiProxyExcludedChannelIds = () => []
+} = require('./channels-implementation');
+const { persistProxyRequestSnapshot } = require('../../../server/services/request-logger');
+const { redirectModel: redirectModelBase, resolveTargetUrl } = require('../../../shared/proxy-utils');
+const { attachServerShutdownHandling, expediteServerShutdown } = require('../../../server/services/server-shutdown');
 
 let proxyServer = null;
 let proxyApp = null;
@@ -36,24 +26,7 @@ const requestMetadata = new Map();
 // 格式: { channelId: { "originalModel": "redirectedModel", ... } }
 const printedGeminiRedirectCache = new Map();
 
-// Gemini 模型定价（每百万 tokens 的价格，单位：美元）
-// 作为 model-metadata 未覆盖时的兜底值
-const PRICING = {
-  'gemini-2.5-pro': { input: 1.25, output: 10, cacheRead: 0.125 },
-  'gemini-2.5-flash': { input: 0.3, output: 2.5, cacheRead: 0.03 },
-  'gemini-2.5-flash-lite': { input: 0.1, output: 0.4, cacheRead: 0.01 },
-  'gemini-2.0-flash-exp': { input: 0, output: 0 }, // 实验性免费
-  'gemini-2.0-flash-thinking-exp-1219': { input: 0, output: 0 }, // 实验性免费
-  'gemini-1.5-pro': { input: 1.25, output: 5 },
-  'gemini-1.5-flash': { input: 0.075, output: 0.3 },
-  'gemini-1.5-flash-8b': { input: 0.0375, output: 0.15 },
-  'gemini-1.0-pro': { input: 0.5, output: 1.5 },
-  // 旧版本别名
-  'gemini-pro': { input: 0.5, output: 1.5 },
-  'gemini-pro-vision': { input: 0.5, output: 1.5 }
-};
 
-const GEMINI_BASE_PRICING = DEFAULT_CONFIG.pricing.gemini;
 const jsonBodyParser = express.json({
   limit: '100mb',
   verify: (req, res, buf) => {
@@ -192,43 +165,6 @@ function isHttpErrorStatus(statusCode) {
   return Number.isFinite(code) && (code < 200 || code >= 300);
 }
 
-/**
- * 计算请求成本
- */
-function calculateCost(model, tokens) {
-  // 尝试精确匹配
-  let fallbackPricing = PRICING[model];
-
-  // 如果没有精确匹配，尝试模糊匹配
-  if (!fallbackPricing) {
-    const modelLower = String(model || '').toLowerCase();
-    if (modelLower.includes('gemini-2.5-pro')) {
-      fallbackPricing = PRICING['gemini-2.5-pro'];
-    } else if (modelLower.includes('gemini-2.5-flash-lite')) {
-      fallbackPricing = PRICING['gemini-2.5-flash-lite'];
-    } else if (modelLower.includes('gemini-2.5-flash')) {
-      fallbackPricing = PRICING['gemini-2.5-flash'];
-    } else if (modelLower.includes('gemini-2.0-flash-thinking')) {
-      fallbackPricing = PRICING['gemini-2.0-flash-thinking-exp-1219'];
-    } else if (modelLower.includes('gemini-2.0-flash')) {
-      fallbackPricing = PRICING['gemini-2.0-flash-exp'];
-    } else if (modelLower.includes('gemini-1.5-pro')) {
-      fallbackPricing = PRICING['gemini-1.5-pro'];
-    } else if (modelLower.includes('gemini-1.5-flash-8b')) {
-      fallbackPricing = PRICING['gemini-1.5-flash-8b'];
-    } else if (modelLower.includes('gemini-1.5-flash')) {
-      fallbackPricing = PRICING['gemini-1.5-flash'];
-    } else if (modelLower.includes('gemini-1.0-pro')) {
-      fallbackPricing = PRICING['gemini-1.0-pro'];
-    } else if (modelLower.includes('gemini-pro')) {
-      fallbackPricing = PRICING['gemini-pro'];
-    }
-  }
-
-  const pricing = resolveModelPricing('gemini', model, fallbackPricing, GEMINI_BASE_PRICING);
-  return calculateTokenCost(pricing, tokens, GEMINI_BASE_PRICING);
-}
-
 // 启动 Gemini 代理服务器
 async function startGeminiProxyServer(options = {}) {
   // options.preserveStartTime - 是否保留现有的启动时间（用于切换渠道时）
@@ -238,6 +174,13 @@ async function startGeminiProxyServer(options = {}) {
     console.log('Gemini proxy server already running on port', currentPort);
     return { success: true, port: currentPort };
   }
+  const excludedChannelIds = getGeminiProxyExcludedChannelIds();
+  if (excludedChannelIds.length > 0) {
+    const error = new Error('Gemini dynamic proxy supports API-key channels only; disable OAuth channels first');
+    error.code = 'gemini_oauth_proxy_unsupported';
+    error.statusCode = 409;
+    throw error;
+  }
 
   try {
     const config = loadConfig();
@@ -295,7 +238,11 @@ async function startGeminiProxyServer(options = {}) {
 
     proxyApp.use(async (req, res) => {
       try {
-        const channel = await allocateChannel({ source: 'gemini', enableSessionBinding: false });
+        const channel = await allocateChannel({
+          source: 'gemini',
+          enableSessionBinding: false,
+          excludeChannelIds: getGeminiProxyExcludedChannelIds()
+        });
         req.selectedChannel = channel;
 
         const release = (() => {
@@ -316,14 +263,6 @@ async function startGeminiProxyServer(options = {}) {
         const effectiveKey = getEffectiveApiKey(channel);
         if (!effectiveKey) {
           release();
-          publishFailureLog({
-            source: 'gemini',
-            channel: channel.name,
-            message: 'API key not configured or expired. Please update your channel key.',
-            statusCode: 401,
-            stage: 'preflight',
-            broadcastLog
-          });
           return res.status(401).json({
             error: {
               message: 'API key not configured or expired. Please update your channel key.',
@@ -402,20 +341,6 @@ async function startGeminiProxyServer(options = {}) {
           release();
           if (err) {
             recordFailure(channel.id, 'gemini', err);
-            const metadata = requestMetadata.get(req) || {
-              channel: channel.name,
-              channelId: channel.id,
-              startTime: Date.now()
-            };
-            publishFailureLog({
-              source: 'gemini',
-              metadata,
-              message: err.message,
-              error: err,
-              statusCode: 502,
-              stage: 'proxy_web',
-              broadcastLog
-            });
             console.error('Gemini proxy error:', err);
             if (res && !res.headersSent) {
               res.status(502).json({
@@ -429,13 +354,6 @@ async function startGeminiProxyServer(options = {}) {
         });
       } catch (error) {
         console.error('Gemini channel allocation error:', error);
-        publishFailureLog({
-          source: 'gemini',
-          message: error.message || 'No Gemini channel available',
-          statusCode: 503,
-          stage: 'allocate_channel',
-          broadcastLog
-        });
         if (!res.headersSent) {
           res.status(503).json({
             error: {
@@ -447,170 +365,35 @@ async function startGeminiProxyServer(options = {}) {
       }
     });
 
-    // 监听代理响应 (OpenAI 兼容格式)
+    // 代理响应只负责维护传输健康状态；实时日志和 usage 来自 CLI 原生日志。
     proxy.on('proxyRes', (proxyRes, req, res) => {
       const metadata = requestMetadata.get(req);
-      if (!metadata) {
-        return;
-      }
+      if (!metadata) return;
 
-      // 检查响应是否已关闭
       if (res.writableEnded || res.destroyed) {
         requestMetadata.delete(req);
         return;
       }
 
-      // 标记响应是否已关闭
-      let isResponseClosed = false;
-
-      // 监听响应关闭事件
-      res.on('close', () => {
-        isResponseClosed = true;
-        requestMetadata.delete(req);
-      });
-
-      // 监听响应错误事件
+      res.on('close', () => requestMetadata.delete(req));
       res.on('error', (err) => {
-        isResponseClosed = true;
-        // 忽略客户端断开连接的常见错误
-        if (err.code !== 'EPIPE' && err.code !== 'ECONNRESET') {
-          console.error('Response error:', err);
-        }
+        if (err.code !== 'EPIPE' && err.code !== 'ECONNRESET') console.error('Response error:', err);
+        recordFailure(metadata.channelId, 'gemini', err);
         requestMetadata.delete(req);
       });
 
-      let buffer = '';
-      let tokenData = createTokenData();
-      let usageRecorded = false;
       const upstreamStatusCode = Number(proxyRes.statusCode) || 200;
-      const isUpstreamError = isHttpErrorStatus(upstreamStatusCode);
-      const parsedStream = createDecodedStream(proxyRes);
-
-      function recordUsageIfReady() {
-        if (usageRecorded) {
-          return false;
-        }
-
-        if (!tokenData.model && metadata.modelFromUrl) {
-          tokenData.model = metadata.modelFromUrl;
-        }
-
-        const result = publishUsageLog({
-          source: 'gemini',
-          metadata,
-          model: tokenData.model,
-          tokens: {
-            input: tokenData.inputTokens,
-            output: tokenData.outputTokens,
-            cacheCreation: tokenData.cacheCreation,
-            cacheRead: tokenData.cacheRead,
-            cached: tokenData.cachedTokens,
-            reasoning: tokenData.reasoningTokens,
-            total: tokenData.totalTokens
-          },
-          calculateCost,
-          broadcastLog,
-          recordRequest: recordGeminiRequest,
-          recordSuccess,
-          allowBroadcast: true
-        });
-
-        if (!result) {
-          return false;
-        }
-
-        usageRecorded = true;
-        return true;
-      }
-
-      parsedStream.on('data', (chunk) => {
-        if (isResponseClosed) {
-          return;
-        }
-
-        buffer += chunk.toString('utf8');
-
-        // 检查是否是 SSE 流
-        if (!isUpstreamError && proxyRes.headers['content-type']?.includes('text/event-stream')) {
-          const parsedEvents = splitSSEEvents(buffer);
-          buffer = parsedEvents.remainder;
-
-          parsedEvents.events.forEach((eventText) => {
-            if (!eventText.trim()) return;
-
-            try {
-              const event = parseSSEEventText(eventText);
-              if (!event) return;
-
-              const parsed = JSON.parse(event.data);
-              const usage = parseSSEUsage(parsed, event.eventType);
-              mergeUsageIntoTokenData(tokenData, usage);
-
-              if (usage.isDone) {
-                recordUsageIfReady();
-              }
-            } catch (err) {
-              // 忽略解析错误
-            }
-          });
-        }
-      });
-
-      parsedStream.on('end', () => {
-        if (isUpstreamError) {
-          const message = extractGeminiUpstreamErrorMessage(buffer, upstreamStatusCode);
-          const error = new Error(buffer.trim() || message);
-          recordFailure(metadata.channelId, 'gemini', error);
-          publishFailureLog({
-            source: 'gemini',
-            metadata,
-            message,
-            error,
-            statusCode: upstreamStatusCode,
-            stage: 'upstream_response',
-            broadcastLog
-          });
-
-          if (!isResponseClosed) {
-            requestMetadata.delete(req);
-          }
-          return;
-        }
-
-        // 如果不是流式响应，尝试从完整响应中解析
-        if (!proxyRes.headers['content-type']?.includes('text/event-stream')) {
-          try {
-            const parsed = JSON.parse(buffer);
-            const usage = parseNonStreamingUsage(parsed);
-            mergeUsageIntoTokenData(tokenData, usage);
-          } catch (err) {
-            // 忽略解析错误
-          }
-        }
-
-        recordUsageIfReady();
-
-        if (!isResponseClosed) {
-          requestMetadata.delete(req);
+      proxyRes.on('end', () => {
+        if (isHttpErrorStatus(upstreamStatusCode)) {
+          recordFailure(metadata.channelId, 'gemini', new Error(`Gemini upstream HTTP ${upstreamStatusCode}`));
+        } else {
+          recordSuccess(metadata.channelId, 'gemini');
         }
+        requestMetadata.delete(req);
       });
-
-      parsedStream.on('error', (err) => {
-        // 忽略代理响应错误（可能是网络问题）
-        if (err.code !== 'EPIPE' && err.code !== 'ECONNRESET') {
-          console.error('Proxy response error:', err);
-        }
-        isResponseClosed = true;
+      proxyRes.on('error', (err) => {
+        if (err.code !== 'EPIPE' && err.code !== 'ECONNRESET') console.error('Proxy response error:', err);
         recordFailure(metadata.channelId, 'gemini', err);
-        publishFailureLog({
-          source: 'gemini',
-          metadata,
-          message: err.message,
-          error: err,
-          statusCode: proxyRes.statusCode,
-          stage: 'response_stream',
-          broadcastLog
-        });
         requestMetadata.delete(req);
       });
     });
@@ -623,19 +406,6 @@ async function startGeminiProxyServer(options = {}) {
         releaseChannel(req.selectedChannel.id, 'gemini');
         broadcastSchedulerState('gemini', getSchedulerState('gemini'));
       }
-      publishFailureLog({
-        source: 'gemini',
-        metadata: (req && requestMetadata.get(req)) || {
-          channel: req?.selectedChannel?.name,
-          channelId: req?.selectedChannel?.id,
-          model: req?.body?.model
-        },
-        message: err.message,
-        error: err,
-        statusCode: 502,
-        stage: 'proxy',
-        broadcastLog
-      });
       if (res && !res.headersSent) {
         res.status(502).json({
           error: {
@@ -746,7 +516,6 @@ module.exports = {
   stopGeminiProxyServer,
   getGeminiProxyStatus,
   clearGeminiRedirectCache,
-  calculateCost,
   _test: {
     buildVertexAiV1Path,
     extractGeminiUpstreamErrorMessage,

package/src/platforms/drivers/gemini/proxy.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const { createProxyDriver } = require('../../../shared/proxy-driver');
+
+function createDriver(context = {}) {
+  return createProxyDriver({
+    ...context,
+    platform: 'gemini',
+    servicePath: './gemini/proxy-implementation',
+    localServicePath: '../platforms/drivers/gemini/proxy-implementation',
+    exports: { status: 'getGeminiProxyStatus', start: 'startGeminiProxyServer', stop: 'stopGeminiProxyServer' },
+    cliMetadata: { defaultPort: 20090 }
+  });
+}
+
+module.exports = { createDriver };

package/src/platforms/drivers/gemini/resource-sync.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const { createResourceSyncDriver } = require('../../../shared/driver-factories/resource-sync');
+
+function createDriver(context = {}) {
+  return createResourceSyncDriver({ ...context, platform: 'gemini' });
+}
+
+module.exports = { createDriver };