@adversity/coding-tool-x 3.1.1 → 3.1.2

package/src/server/opencode-proxy-server.js

@@ -17,7 +17,7 @@ const { resolvePricing } = require('./utils/pricing');
 const { recordRequest: recordOpenCodeRequest } = require('./services/opencode-statistics-service');
 const { saveProxyStartTime, clearProxyStartTime, getProxyStartTime, getProxyRuntime } = require('./services/proxy-runtime');
 const { getEnabledChannels, getEffectiveApiKey } = require('./services/opencode-channels');
-const { probeModelAvailability, fetchModelsFromProvider } = require('./services/model-detector');
+const { probeModelAvailability, fetchModelsFromProvider, getCachedModelInfo } = require('./services/model-detector');
 const { CLAUDE_MODEL_PRICING } = require('../config/model-pricing');
 
 let proxyServer = null;
@@ -60,6 +60,21 @@ const GEMINI_CLI_CLIENT_METADATA = 'ideType=IDE_UNSPECIFIED,platform=PLATFORM_UN
 const CLAUDE_SESSION_USER_ID_TTL_MS = 60 * 60 * 1000;
 const CLAUDE_SESSION_USER_ID_CACHE_MAX = 2000;
 const claudeSessionUserIdCache = new Map();
+const FILE_EXTENSION_MIME_TYPES = {
+  '.pdf': 'application/pdf',
+  '.txt': 'text/plain',
+  '.md': 'text/markdown',
+  '.csv': 'text/csv',
+  '.json': 'application/json',
+  '.xml': 'application/xml',
+  '.html': 'text/html',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.svg': 'image/svg+xml'
+};
 
 /**
  * 检测模型层级
@@ -216,9 +231,17 @@ function calculateCost(model, tokens) {
   pricing = resolvePricing('opencode', pricing, OPENCODE_BASE_PRICING);
   const inputRate = typeof pricing.input === 'number' ? pricing.input : OPENCODE_BASE_PRICING.input;
   const outputRate = typeof pricing.output === 'number' ? pricing.output : OPENCODE_BASE_PRICING.output;
+  const cacheCreationRate = typeof pricing.cacheCreation === 'number' ? pricing.cacheCreation : inputRate * 1.25;
+  const cacheReadRate = typeof pricing.cacheRead === 'number' ? pricing.cacheRead : inputRate * 0.1;
+
+  const cacheCreationTokens = tokens.cacheCreation || 0;
+  const cacheReadTokens = tokens.cacheRead || 0;
+  const regularInputTokens = Math.max(0, (tokens.input || 0) - cacheCreationTokens - cacheReadTokens);
 
   return (
-    (tokens.input || 0) * inputRate / ONE_MILLION +
+    regularInputTokens * inputRate / ONE_MILLION +
+    cacheCreationTokens * cacheCreationRate / ONE_MILLION +
+    cacheReadTokens * cacheReadRate / ONE_MILLION +
     (tokens.output || 0) * outputRate / ONE_MILLION
   );
 }
@@ -369,12 +392,20 @@ function getRequestPathname(urlPath = '') {
   }
 }
 
+function normalizeGatewayPath(pathname = '') {
+  const normalized = String(pathname || '').trim();
+  if (!normalized) return '/';
+  return normalized.replace(/\/+$/, '') || '/';
+}
+
 function isResponsesPath(pathname) {
-  return pathname === '/v1/responses' || pathname === '/responses';
+  const normalized = normalizeGatewayPath(pathname);
+  return normalized.endsWith('/v1/responses') || normalized.endsWith('/responses');
 }
 
 function isChatCompletionsPath(pathname) {
-  return pathname === '/v1/chat/completions' || pathname === '/chat/completions';
+  const normalized = normalizeGatewayPath(pathname);
+  return normalized.endsWith('/v1/chat/completions') || normalized.endsWith('/chat/completions');
 }
 
 function collectPreferredProbeModels(channel) {
@@ -461,10 +492,192 @@ function extractText(value) {
   return fragments.join('\n').trim();
 }
 
+function parseBase64DataUrl(dataUrl = '') {
+  const value = typeof dataUrl === 'string' ? dataUrl.trim() : '';
+  if (!value) return null;
+  const matched = value.match(/^data:([^;,]+)?;base64,(.+)$/i);
+  if (!matched) return null;
+  return {
+    mediaType: String(matched[1] || '').trim(),
+    data: String(matched[2] || '')
+  };
+}
+
+function inferMimeTypeFromFilename(filename = '', fallback = 'application/octet-stream') {
+  const ext = path.extname(String(filename || '').trim()).toLowerCase();
+  if (!ext) return fallback;
+  return FILE_EXTENSION_MIME_TYPES[ext] || fallback;
+}
+
+function normalizeOpenAiImageBlock(value) {
+  let imageUrl = '';
+  if (typeof value === 'string') {
+    imageUrl = value;
+  } else if (value && typeof value === 'object') {
+    if (typeof value.url === 'string') {
+      imageUrl = value.url;
+    } else if (typeof value.image_url === 'string') {
+      imageUrl = value.image_url;
+    } else if (value.image_url && typeof value.image_url === 'object' && typeof value.image_url.url === 'string') {
+      imageUrl = value.image_url.url;
+    }
+  }
+
+  const normalizedUrl = String(imageUrl || '').trim();
+  if (!normalizedUrl) return null;
+
+  const parsedDataUrl = parseBase64DataUrl(normalizedUrl);
+  if (parsedDataUrl && parsedDataUrl.data) {
+    const mediaType = parsedDataUrl.mediaType && parsedDataUrl.mediaType.startsWith('image/')
+      ? parsedDataUrl.mediaType
+      : 'image/png';
+    return {
+      type: 'image',
+      source: {
+        type: 'base64',
+        media_type: mediaType,
+        data: parsedDataUrl.data
+      }
+    };
+  }
+
+  return {
+    type: 'image',
+    source: {
+      type: 'url',
+      url: normalizedUrl
+    }
+  };
+}
+
+function normalizeOpenAiFileBlock(value) {
+  if (!value || typeof value !== 'object') return null;
+  const filePayload = (value.file && typeof value.file === 'object' && !Array.isArray(value.file))
+    ? value.file
+    : value;
+  const filename = typeof filePayload.filename === 'string' ? filePayload.filename.trim() : '';
+  const rawMediaType = typeof filePayload.mime_type === 'string'
+    ? filePayload.mime_type.trim()
+    : (typeof filePayload.media_type === 'string' ? filePayload.media_type.trim() : '');
+  const mediaType = rawMediaType || inferMimeTypeFromFilename(filename);
+  const fileData = typeof filePayload.file_data === 'string' ? filePayload.file_data.trim() : '';
+  const fileUrl = typeof filePayload.file_url === 'string'
+    ? filePayload.file_url.trim()
+    : (typeof filePayload.url === 'string' ? filePayload.url.trim() : '');
+  const fileId = typeof filePayload.file_id === 'string' ? filePayload.file_id.trim() : '';
+
+  if (fileData) {
+    const parsedDataUrl = parseBase64DataUrl(fileData);
+    if (parsedDataUrl && parsedDataUrl.data) {
+      return {
+        type: 'document',
+        source: {
+          type: 'base64',
+          media_type: parsedDataUrl.mediaType || mediaType,
+          data: parsedDataUrl.data
+        }
+      };
+    }
+
+    return {
+      type: 'document',
+      source: {
+        type: 'base64',
+        media_type: mediaType,
+        data: fileData
+      }
+    };
+  }
+
+  if (fileUrl) {
+    return {
+      type: 'document',
+      source: {
+        type: 'url',
+        url: fileUrl
+      }
+    };
+  }
+
+  if (fileId) {
+    return {
+      type: 'text',
+      text: `[input_file:${fileId}]`
+    };
+  }
+
+  return null;
+}
+
+function normalizeOpenAiContentItemToClaudeBlocks(item) {
+  if (item === null || item === undefined) return [];
+
+  if (typeof item === 'string' || typeof item === 'number' || typeof item === 'boolean') {
+    const text = String(item);
+    return text.trim() ? [{ type: 'text', text }] : [];
+  }
+
+  if (Array.isArray(item)) {
+    return item.flatMap(normalizeOpenAiContentItemToClaudeBlocks);
+  }
+
+  if (typeof item !== 'object') return [];
+
+  const itemType = String(item.type || '').trim().toLowerCase();
+  if (itemType === 'tool_use' || itemType === 'tool_result') {
+    return [item];
+  }
+
+  if (itemType === 'image' && item.source && typeof item.source === 'object') {
+    return [item];
+  }
+  if (itemType === 'document' && item.source && typeof item.source === 'object') {
+    return [item];
+  }
+
+  if (itemType === 'text' || itemType === 'input_text' || itemType === 'output_text') {
+    const text = typeof item.text === 'string' ? item.text : '';
+    if (!text.trim()) return [];
+    const block = { type: 'text', text };
+    if (item.cache_control && typeof item.cache_control === 'object') {
+      block.cache_control = item.cache_control;
+    }
+    return [block];
+  }
+
+  if (itemType === 'image_url' || itemType === 'input_image') {
+    const imageBlock = normalizeOpenAiImageBlock(item);
+    return imageBlock ? [imageBlock] : [];
+  }
+
+  if (itemType === 'file' || itemType === 'input_file') {
+    const fileBlock = normalizeOpenAiFileBlock(item);
+    return fileBlock ? [fileBlock] : [];
+  }
+
+  if (item.image_url !== undefined || item.url !== undefined) {
+    const imageBlock = normalizeOpenAiImageBlock(item);
+    if (imageBlock) return [imageBlock];
+  }
+
+  if (item.file !== undefined || item.file_data !== undefined || item.file_url !== undefined || item.file_id !== undefined) {
+    const fileBlock = normalizeOpenAiFileBlock(item);
+    if (fileBlock) return [fileBlock];
+  }
+
+  const fallbackText = extractText(item);
+  return fallbackText ? [{ type: 'text', text: fallbackText }] : [];
+}
+
+function normalizeOpenAiContentToClaudeBlocks(content) {
+  return normalizeOpenAiContentItemToClaudeBlocks(content);
+}
+
 function normalizeOpenAiRole(role) {
   const value = String(role || '').trim().toLowerCase();
   if (value === 'assistant' || value === 'model') return 'assistant';
-  if (value === 'system') return 'system';
+  if (value === 'system' || value === 'developer') return 'system';
+  if (value === 'tool') return 'tool';
   return 'user';
 }
 
@@ -521,6 +734,17 @@ function normalizeToolChoiceToClaude(toolChoice) {
   return undefined;
 }
 
+function normalizeReasoningEffortToClaude(reasoningEffort) {
+  const effort = String(reasoningEffort || '').trim().toLowerCase();
+  if (!effort) return undefined;
+  if (effort === 'none') return { type: 'disabled' };
+  if (effort === 'auto') return { type: 'enabled' };
+  if (effort === 'low') return { type: 'enabled', budget_tokens: 2048 };
+  if (effort === 'medium') return { type: 'enabled', budget_tokens: 8192 };
+  if (effort === 'high') return { type: 'enabled', budget_tokens: 24576 };
+  return undefined;
+}
+
 function generateToolCallId() {
   return `toolu_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
 }
@@ -597,24 +821,41 @@ function buildUserToolResultMessage(item) {
 }
 
 function normalizeOpenCodeMessages(pathname, payload = {}) {
-  const systemParts = [];
+  const systemBlocks = [];
   const messages = [];
 
   if (isResponsesPath(pathname) && typeof payload.instructions === 'string' && payload.instructions.trim()) {
-    systemParts.push(payload.instructions.trim());
+    systemBlocks.push({ type: 'text', text: payload.instructions.trim() });
   }
 
-  const appendMessage = (role, content) => {
+  const appendMessage = (role, content, topLevelCacheControl) => {
     const normalizedRole = normalizeOpenAiRole(role);
-    const text = extractText(content);
-    if (!text) return;
+    const contentBlocks = normalizeOpenAiContentToClaudeBlocks(content);
     if (normalizedRole === 'system') {
-      systemParts.push(text);
+      const blocks = contentBlocks
+        .filter(block => block && block.type === 'text' && typeof block.text === 'string' && block.text.trim());
+      blocks.forEach((block, idx) => {
+        const systemBlock = { type: 'text', text: block.text };
+        if (block.cache_control && typeof block.cache_control === 'object') {
+          systemBlock.cache_control = block.cache_control;
+        } else if (topLevelCacheControl && typeof topLevelCacheControl === 'object' && idx === blocks.length - 1) {
+          // 消息顶层的 cache_control（OpenCode/Vercel AI SDK 注入方式）打在最后一个 block 上
+          systemBlock.cache_control = topLevelCacheControl;
+        }
+        systemBlocks.push(systemBlock);
+      });
       return;
     }
+
+    if (!Array.isArray(contentBlocks) || contentBlocks.length === 0) return;
+    // 将消息顶层的 cache_control 传递到最后一个 content block 上
+    if (topLevelCacheControl && typeof topLevelCacheControl === 'object' && contentBlocks.length > 0) {
+      const lastBlock = contentBlocks[contentBlocks.length - 1];
+      if (!lastBlock.cache_control) lastBlock.cache_control = topLevelCacheControl;
+    }
     messages.push({
       role: normalizedRole === 'assistant' ? 'assistant' : 'user',
-      content: [{ type: 'text', text }]
+      content: contentBlocks
     });
   };
 
@@ -636,7 +877,7 @@ function normalizeOpenCodeMessages(pathname, payload = {}) {
           return;
         }
         if (item.type === 'message' || item.role) {
-          appendMessage(item.role, item.content);
+          appendMessage(item.role, item.content, item.cache_control);
         }
       });
     }
@@ -650,11 +891,7 @@ function normalizeOpenCodeMessages(pathname, payload = {}) {
         return;
       }
       if (message.role === 'assistant' && Array.isArray(message.tool_calls) && message.tool_calls.length > 0) {
-        const assistantContent = [];
-        const text = extractText(message.content);
-        if (text) {
-          assistantContent.push({ type: 'text', text });
-        }
+        const assistantContent = normalizeOpenAiContentToClaudeBlocks(message.content);
 
         message.tool_calls.forEach(toolCall => {
           if (!toolCall || typeof toolCall !== 'object') return;
@@ -679,7 +916,7 @@ function normalizeOpenCodeMessages(pathname, payload = {}) {
         }
         return;
       }
-      appendMessage(message.role, message.content);
+      appendMessage(message.role, message.content, message.cache_control);
     });
   }
 
@@ -691,7 +928,7 @@ function normalizeOpenCodeMessages(pathname, payload = {}) {
   }
 
   return {
-    system: systemParts.join('\n\n').trim(),
+    systemBlocks,
     messages
   };
 }
@@ -710,9 +947,61 @@ function normalizeClaudeMetadata(metadata, fallbackUserId = '') {
   return normalized;
 }
 
+function applyPromptCachingToClaudePayload(converted) {
+  const EPHEMERAL = { type: 'ephemeral' };
+
+  // 统计 messages 中上游（OpenCode）已注入的缓存断点数量
+  // OpenCode 策略：对最后2条非system消息打断点，我们不重复注入
+  let messageBreakpoints = 0;
+  if (Array.isArray(converted.messages)) {
+    converted.messages.forEach(msg => {
+      if (Array.isArray(msg.content)) {
+        msg.content.forEach(block => {
+          if (block.cache_control) messageBreakpoints++;
+          if (block.type === 'tool_result' && Array.isArray(block.content)) {
+            block.content.forEach(inner => {
+              if (inner.cache_control) messageBreakpoints++;
+            });
+          }
+        });
+      }
+    });
+  }
+
+  // 统计 system 中已有的断点
+  let systemBreakpoints = 0;
+  if (Array.isArray(converted.system)) {
+    converted.system.forEach(block => {
+      if (block.cache_control) systemBreakpoints++;
+    });
+  }
+
+  // 若 messages 已有断点，说明上游（OpenCode）已处理，不再注入 messages 断点
+  // 只在 system blocks 没有断点时补充（OpenCode 不操作 system，由我们负责）
+  if (systemBreakpoints === 0 && Array.isArray(converted.system) && converted.system.length > 0) {
+    const last = converted.system[converted.system.length - 1];
+    if (!last.cache_control) last.cache_control = EPHEMERAL;
+  }
+
+  // 若上游完全没有注入任何断点（非 OpenCode 客户端），按原策略补充 messages 断点
+  if (messageBreakpoints === 0 && systemBreakpoints === 0) {
+    // 对最后2条消息打断点，与 OpenCode 策略对齐
+    if (Array.isArray(converted.messages) && converted.messages.length > 0) {
+      for (const msg of converted.messages.slice(-2)) {
+        if (Array.isArray(msg.content) && msg.content.length > 0) {
+          const last = msg.content[msg.content.length - 1];
+          if (!last.cache_control) last.cache_control = EPHEMERAL;
+        }
+      }
+    }
+  }
+}
+
 function convertOpenCodePayloadToClaude(pathname, payload = {}, fallbackModel = '', options = {}) {
   const normalized = normalizeOpenCodeMessages(pathname, payload);
   const maxTokens = Number(payload.max_output_tokens ?? payload.max_tokens);
+  const stopSequences = normalizeStopSequences(payload.stop);
+  const thinking = normalizeReasoningEffortToClaude(payload.reasoning_effort);
 
   const converted = {
     model: payload.model || fallbackModel || 'claude-sonnet-4-20250514',
@@ -721,14 +1010,10 @@ function convertOpenCodePayloadToClaude(pathname, payload = {}, fallbackModel =
     messages: normalized.messages
   };
 
-  if (normalized.system) {
+  if (normalized.systemBlocks && normalized.systemBlocks.length > 0) {
     // 部分 relay 仅接受 Claude system 的 block 数组格式，不接受纯字符串
-    converted.system = [
-      {
-        type: 'text',
-        text: normalized.system
-      }
-    ];
+    // 保留原始 cache_control 字段，确保 prompt cache 正常命中
+    converted.system = normalized.systemBlocks;
   }
 
   const tools = normalizeOpenAiToolsToClaude(payload.tools || []);
@@ -740,6 +1025,12 @@ function convertOpenCodePayloadToClaude(pathname, payload = {}, fallbackModel =
   if (toolChoice) {
     converted.tool_choice = toolChoice;
   }
+  if (stopSequences) {
+    converted.stop_sequences = stopSequences;
+  }
+  if (thinking) {
+    converted.thinking = thinking;
+  }
 
   if (Number.isFinite(Number(payload.temperature))) {
     converted.temperature = Number(payload.temperature);
@@ -754,6 +1045,9 @@ function convertOpenCodePayloadToClaude(pathname, payload = {}, fallbackModel =
   // 某些 Claude relay 会校验 metadata.user_id 以识别 Claude Code 请求
   converted.metadata = normalizeClaudeMetadata(payload.metadata, options.sessionUserId);
 
+  // 注入 prompt cache 断点，对齐 Anthropic AI SDK 的自动缓存行为
+  applyPromptCachingToClaudePayload(converted);
+
   return converted;
 }
 
@@ -761,6 +1055,12 @@ function normalizeOpenAiToolsToGemini(tools = []) {
   if (!Array.isArray(tools)) return [];
 
   const functionDeclarations = [];
+  const builtInTools = [];
+  const appendBuiltInTool = (toolNode) => {
+    if (!toolNode || typeof toolNode !== 'object') return;
+    builtInTools.push(toolNode);
+  };
+
   for (const tool of tools) {
     if (!tool || typeof tool !== 'object') continue;
 
@@ -781,11 +1081,56 @@ function normalizeOpenAiToolsToGemini(tools = []) {
         description: tool.description || '',
         parameters: tool.parameters || { type: 'object', properties: {} }
       });
+      continue;
+    }
+
+    const normalizedType = String(tool.type || '').trim().toLowerCase();
+
+    if (tool.google_search && typeof tool.google_search === 'object') {
+      appendBuiltInTool({ googleSearch: tool.google_search });
+      continue;
+    }
+    if (tool.code_execution && typeof tool.code_execution === 'object') {
+      appendBuiltInTool({ codeExecution: tool.code_execution });
+      continue;
+    }
+    if (tool.url_context && typeof tool.url_context === 'object') {
+      appendBuiltInTool({ urlContext: tool.url_context });
+      continue;
+    }
+
+    if (normalizedType === 'google_search' || normalizedType === 'web_search' || normalizedType === 'web_search_preview') {
+      const searchConfig = (tool.web_search && typeof tool.web_search === 'object')
+        ? tool.web_search
+        : ((tool.googleSearch && typeof tool.googleSearch === 'object') ? tool.googleSearch : {});
+      appendBuiltInTool({ googleSearch: searchConfig });
+      continue;
+    }
+
+    if (normalizedType === 'code_execution' || normalizedType === 'code_interpreter') {
+      const executionConfig = (tool.codeExecution && typeof tool.codeExecution === 'object')
+        ? tool.codeExecution
+        : {};
+      appendBuiltInTool({ codeExecution: executionConfig });
+      continue;
+    }
+
+    if (normalizedType === 'url_context') {
+      const urlContextConfig = (tool.urlContext && typeof tool.urlContext === 'object')
+        ? tool.urlContext
+        : {};
+      appendBuiltInTool({ urlContext: urlContextConfig });
     }
   }
 
-  if (functionDeclarations.length === 0) return [];
-  return [{ functionDeclarations }];
+  const normalizedTools = [];
+  if (functionDeclarations.length > 0) {
+    normalizedTools.push({ functionDeclarations });
+  }
+  if (builtInTools.length > 0) {
+    normalizedTools.push(...builtInTools);
+  }
+  return normalizedTools;
 }
 
 function normalizeToolChoiceToGemini(toolChoice) {
@@ -828,6 +1173,44 @@ function normalizeToolChoiceToGemini(toolChoice) {
   return undefined;
 }
 
+function normalizeReasoningEffortToGemini(reasoningEffort) {
+  const effort = String(reasoningEffort || '').trim().toLowerCase();
+  if (!effort) return undefined;
+  if (effort === 'none') {
+    return {
+      includeThoughts: false,
+      thinkingBudget: 0
+    };
+  }
+  if (effort === 'auto') {
+    return {
+      includeThoughts: true,
+      thinkingBudget: -1
+    };
+  }
+  if (effort === 'low' || effort === 'medium' || effort === 'high') {
+    return {
+      includeThoughts: true,
+      thinkingLevel: effort
+    };
+  }
+  return undefined;
+}
+
+function normalizeGeminiResponseModalities(modalities) {
+  if (!Array.isArray(modalities)) return undefined;
+  const mapped = modalities
+    .map(item => String(item || '').trim().toLowerCase())
+    .filter(Boolean)
+    .map(item => {
+      if (item === 'text') return 'TEXT';
+      if (item === 'image') return 'IMAGE';
+      return '';
+    })
+    .filter(Boolean);
+  return mapped.length > 0 ? mapped : undefined;
+}
+
 function normalizeStopSequences(stopValue) {
   if (!stopValue) return undefined;
   if (typeof stopValue === 'string' && stopValue.trim()) {
@@ -863,6 +1246,42 @@ function normalizeGeminiFunctionResponsePayload(value) {
   return { content: normalizeToolResultContent(value) };
 }
 
+function normalizeGeminiMediaType(value, fallback = 'application/octet-stream') {
+  const mediaType = typeof value === 'string' ? value.trim() : '';
+  return mediaType || fallback;
+}
+
+function buildGeminiPartFromClaudeMediaBlock(block) {
+  if (!block || typeof block !== 'object') return null;
+  const source = (block.source && typeof block.source === 'object') ? block.source : null;
+  if (!source) return null;
+
+  const blockType = String(block.type || '').trim().toLowerCase();
+  const defaultMimeType = blockType === 'image' ? 'image/png' : 'application/octet-stream';
+  const sourceType = String(source.type || '').trim().toLowerCase();
+  const mediaType = normalizeGeminiMediaType(source.media_type || source.mime_type, defaultMimeType);
+
+  if (sourceType === 'base64' && typeof source.data === 'string' && source.data.trim()) {
+    return {
+      inlineData: {
+        mimeType: mediaType,
+        data: source.data
+      }
+    };
+  }
+
+  if (sourceType === 'url' && typeof source.url === 'string' && source.url.trim()) {
+    return {
+      fileData: {
+        mimeType: mediaType,
+        fileUri: source.url.trim()
+      }
+    };
+  }
+
+  return null;
+}
+
 function buildGeminiContents(messages = []) {
   const contents = [];
   const toolNameById = new Map();
@@ -917,6 +1336,14 @@ function buildGeminiContents(messages = []) {
         continue;
       }
 
+      if (block.type === 'image' || block.type === 'document') {
+        const mediaPart = buildGeminiPartFromClaudeMediaBlock(block);
+        if (mediaPart) {
+          parts.push(mediaPart);
+          continue;
+        }
+      }
+
       const text = extractText(block);
       if (text) {
         parts.push({ text });
@@ -1014,14 +1441,20 @@ function convertOpenCodePayloadToGemini(pathname, payload = {}, fallbackModel =
   const stopSequences = normalizeStopSequences(payload.stop);
   const tools = normalizeOpenAiToolsToGemini(payload.tools || []);
   const toolConfig = normalizeToolChoiceToGemini(payload.tool_choice);
+  const thinkingConfig = normalizeReasoningEffortToGemini(payload.reasoning_effort);
+  const candidateCount = Number(payload.n);
+  const responseModalities = normalizeGeminiResponseModalities(payload.modalities);
+  const imageConfig = (payload.image_config && typeof payload.image_config === 'object' && !Array.isArray(payload.image_config))
+    ? payload.image_config
+    : null;
 
   const requestBody = {
     contents: buildGeminiContents(normalized.messages)
   };
 
-  if (normalized.system) {
+  if (normalized.systemBlocks && normalized.systemBlocks.length > 0) {
     requestBody.systemInstruction = {
-      parts: [{ text: normalized.system }]
+      parts: normalized.systemBlocks.map(block => ({ text: block.text || '' })).filter(p => p.text)
     };
   }
 
@@ -1041,6 +1474,27 @@ function convertOpenCodePayloadToGemini(pathname, payload = {}, fallbackModel =
   if (stopSequences) {
     generationConfig.stopSequences = stopSequences;
   }
+  if (thinkingConfig) {
+    generationConfig.thinkingConfig = thinkingConfig;
+  }
+  if (Number.isFinite(candidateCount) && candidateCount > 1) {
+    generationConfig.candidateCount = Math.round(candidateCount);
+  }
+  if (responseModalities) {
+    generationConfig.responseModalities = responseModalities;
+  }
+  if (imageConfig) {
+    const mappedImageConfig = {};
+    if (typeof imageConfig.aspect_ratio === 'string' && imageConfig.aspect_ratio.trim()) {
+      mappedImageConfig.aspectRatio = imageConfig.aspect_ratio.trim();
+    }
+    if (typeof imageConfig.image_size === 'string' && imageConfig.image_size.trim()) {
+      mappedImageConfig.imageSize = imageConfig.image_size.trim();
+    }
+    if (Object.keys(mappedImageConfig).length > 0) {
+      generationConfig.imageConfig = mappedImageConfig;
+    }
+  }
   if (Object.keys(generationConfig).length > 0) {
     requestBody.generationConfig = generationConfig;
   }
@@ -1314,12 +1768,22 @@ function extractClaudeResponseContent(claudeResponse = {}) {
   const textFragments = [];
   const functionCalls = [];
   const reasoningItems = [];
-
-  if (!Array.isArray(claudeResponse.content)) {
+  const nestedResponse = claudeResponse?.response && typeof claudeResponse.response === 'object'
+    ? claudeResponse.response
+    : null;
+  const contentBlocks = Array.isArray(claudeResponse.content)
+    ? claudeResponse.content
+    : (Array.isArray(nestedResponse?.content) ? nestedResponse.content : null);
+
+  if (!Array.isArray(contentBlocks)) {
+    const messageContent = claudeResponse?.choices?.[0]?.message?.content;
+    if (typeof messageContent === 'string' && messageContent.trim()) {
+      return { text: messageContent.trim(), functionCalls: [], reasoningItems: [] };
+    }
     return { text: '', functionCalls: [], reasoningItems: [] };
   }
 
-  claudeResponse.content.forEach(block => {
+  contentBlocks.forEach(block => {
     if (!block || typeof block !== 'object') return;
 
     if (typeof block.text === 'string' && block.text.trim()) {
@@ -1357,6 +1821,109 @@ function extractClaudeResponseContent(claudeResponse = {}) {
   };
 }
 
+function toNumberOrZero(value) {
+  const num = Number(value);
+  return Number.isFinite(num) ? num : 0;
+}
+
+function pickFirstFiniteNumber(values = []) {
+  for (const value of values) {
+    const num = Number(value);
+    if (Number.isFinite(num)) return num;
+  }
+  return null;
+}
+
+function extractClaudeLikeUsage(claudeResponse = {}) {
+  const nestedResponse = claudeResponse?.response && typeof claudeResponse.response === 'object'
+    ? claudeResponse.response
+    : {};
+  const messageObject = claudeResponse?.message && typeof claudeResponse.message === 'object'
+    ? claudeResponse.message
+    : {};
+
+  const usageCandidates = [
+    claudeResponse?.usage,
+    nestedResponse?.usage,
+    messageObject?.usage
+  ].filter(item => item && typeof item === 'object');
+
+  const metadataCandidates = [
+    claudeResponse?.providerMetadata,
+    nestedResponse?.providerMetadata,
+    claudeResponse?.metadata,
+    nestedResponse?.metadata
+  ].filter(item => item && typeof item === 'object');
+
+  const inputTokens = pickFirstFiniteNumber(
+    usageCandidates.flatMap(usage => [
+      usage.input_tokens,
+      usage.prompt_tokens,
+      usage.inputTokens,
+      usage.promptTokens
+    ])
+  );
+
+  const outputTokens = pickFirstFiniteNumber(
+    usageCandidates.flatMap(usage => [
+      usage.output_tokens,
+      usage.completion_tokens,
+      usage.outputTokens,
+      usage.completionTokens
+    ])
+  );
+
+  const totalTokens = pickFirstFiniteNumber(
+    usageCandidates.flatMap(usage => [
+      usage.total_tokens,
+      usage.totalTokens
+    ])
+  );
+
+  const cacheReadTokens = pickFirstFiniteNumber(
+    usageCandidates.flatMap(usage => [
+      usage.cache_read_input_tokens,
+      usage.cacheReadInputTokens,
+      usage.input_tokens_details?.cached_tokens,
+      usage.prompt_tokens_details?.cached_tokens
+    ])
+  );
+
+  const cacheCreationFromUsage = pickFirstFiniteNumber(
+    usageCandidates.flatMap(usage => [
+      usage.cache_creation_input_tokens,
+      usage.cacheCreationInputTokens
+    ])
+  );
+  const cacheCreationFromMetadata = pickFirstFiniteNumber(
+    metadataCandidates.flatMap(metadata => [
+      metadata?.anthropic?.cacheCreationInputTokens,
+      metadata?.venice?.usage?.cacheCreationInputTokens,
+      metadata?.bedrock?.usage?.cacheWriteInputTokens
+    ])
+  );
+
+  const reasoningTokens = pickFirstFiniteNumber(
+    usageCandidates.flatMap(usage => [
+      usage.output_tokens_details?.reasoning_tokens,
+      usage.completion_tokens_details?.reasoning_tokens,
+      usage.reasoning_tokens,
+      usage.reasoningTokens
+    ])
+  );
+
+  return {
+    inputTokens: toNumberOrZero(inputTokens),
+    outputTokens: toNumberOrZero(outputTokens),
+    totalTokens: toNumberOrZero(totalTokens),
+    cacheReadTokens: toNumberOrZero(cacheReadTokens),
+    cacheCreationTokens: toNumberOrZero(
+      cacheCreationFromMetadata !== null ? cacheCreationFromMetadata : cacheCreationFromUsage
+    ),
+    reasoningTokens: toNumberOrZero(reasoningTokens)
+  };
+}
+
 function extractClaudeResponseText(claudeResponse = {}) {
   return extractClaudeResponseContent(claudeResponse).text;
 }
@@ -1460,13 +2027,17 @@ function mapGeminiFinishReasonToChatFinishReason(finishReason, hasToolCalls = fa
 }
 
 function buildOpenAiResponsesObject(claudeResponse = {}, fallbackModel = '') {
-  const inputTokens = Number(claudeResponse?.usage?.input_tokens || 0);
-  const outputTokens = Number(claudeResponse?.usage?.output_tokens || 0);
-  const totalTokens = Number(claudeResponse?.usage?.total_tokens || (inputTokens + outputTokens));
+  const usage = extractClaudeLikeUsage(claudeResponse);
+  const inputTokens = usage.inputTokens;
+  const outputTokens = usage.outputTokens;
+  const totalTokens = usage.totalTokens > 0 ? usage.totalTokens : (inputTokens + outputTokens);
+  const cacheCreationTokens = usage.cacheCreationTokens;
+  const cacheReadTokens = usage.cacheReadTokens;
   const parsedContent = extractClaudeResponseContent(claudeResponse);
   const text = parsedContent.text;
-  const reasoningTokens = parsedContent.reasoningItems.reduce((acc, item) => acc + Math.floor((item.text || '').length / 4), 0);
-  const model = claudeResponse.model || fallbackModel || '';
+  const estimatedReasoningTokens = parsedContent.reasoningItems.reduce((acc, item) => acc + Math.floor((item.text || '').length / 4), 0);
+  const reasoningTokens = usage.reasoningTokens > 0 ? usage.reasoningTokens : estimatedReasoningTokens;
+  const model = claudeResponse.model || claudeResponse?.response?.model || fallbackModel || '';
   const responseId = `resp_${String(claudeResponse.id || Date.now()).replace(/[^a-zA-Z0-9_]/g, '')}`;
   const messageId = claudeResponse.id || `msg_${Date.now()}`;
   const createdAt = Math.floor(Date.now() / 1000);
@@ -1512,7 +2083,7 @@ function buildOpenAiResponsesObject(claudeResponse = {}, fallbackModel = '') {
     });
   });
 
-  return {
+  const responseObject = {
     id: responseId,
     object: 'response',
     created_at: createdAt,
@@ -1523,9 +2094,21 @@ function buildOpenAiResponsesObject(claudeResponse = {}, fallbackModel = '') {
       input_tokens: inputTokens,
       output_tokens: outputTokens,
       total_tokens: totalTokens,
+      ...(cacheReadTokens > 0 ? { input_tokens_details: { cached_tokens: cacheReadTokens } } : {}),
       ...(reasoningTokens > 0 ? { output_tokens_details: { reasoning_tokens: reasoningTokens } } : {})
     }
   };
+
+  if (cacheCreationTokens > 0 || cacheReadTokens > 0) {
+    responseObject.providerMetadata = {
+      anthropic: {
+        ...(cacheCreationTokens > 0 ? { cacheCreationInputTokens: cacheCreationTokens } : {}),
+        ...(cacheReadTokens > 0 ? { cacheReadInputTokens: cacheReadTokens } : {})
+      }
+    };
+  }
+
+  return responseObject;
 }
 
 function buildOpenAiResponsesObjectFromGemini(geminiResponse = {}, fallbackModel = '') {
@@ -1599,12 +2182,16 @@ function buildOpenAiResponsesObjectFromGemini(geminiResponse = {}, fallbackModel
 }
 
 function buildOpenAiChatCompletionsObject(claudeResponse = {}, fallbackModel = '') {
-  const inputTokens = Number(claudeResponse?.usage?.input_tokens || 0);
-  const outputTokens = Number(claudeResponse?.usage?.output_tokens || 0);
-  const totalTokens = Number(claudeResponse?.usage?.total_tokens || (inputTokens + outputTokens));
+  const usage = extractClaudeLikeUsage(claudeResponse);
+  const inputTokens = usage.inputTokens;
+  const outputTokens = usage.outputTokens;
+  const totalTokens = usage.totalTokens > 0 ? usage.totalTokens : (inputTokens + outputTokens);
+  const cachedTokens = usage.cacheReadTokens;
   const parsedContent = extractClaudeResponseContent(claudeResponse);
+  const estimatedReasoningTokens = parsedContent.reasoningItems.reduce((acc, item) => acc + Math.floor((item.text || '').length / 4), 0);
+  const reasoningTokens = usage.reasoningTokens > 0 ? usage.reasoningTokens : estimatedReasoningTokens;
   const text = parsedContent.text;
-  const model = claudeResponse.model || fallbackModel || '';
+  const model = claudeResponse.model || claudeResponse?.response?.model || fallbackModel || '';
   const chatId = `chatcmpl_${String(claudeResponse.id || Date.now()).replace(/[^a-zA-Z0-9_]/g, '')}`;
   const created = Math.floor(Date.now() / 1000);
   const hasToolCalls = parsedContent.functionCalls.length > 0;
@@ -1639,7 +2226,9 @@ function buildOpenAiChatCompletionsObject(claudeResponse = {}, fallbackModel = '
     usage: {
       prompt_tokens: inputTokens,
       completion_tokens: outputTokens,
-      total_tokens: totalTokens
+      total_tokens: totalTokens,
+      ...(cachedTokens > 0 ? { prompt_tokens_details: { cached_tokens: cachedTokens } } : {}),
+      ...(reasoningTokens > 0 ? { completion_tokens_details: { reasoning_tokens: reasoningTokens } } : {})
     }
   };
 }
@@ -1648,6 +2237,9 @@ function buildOpenAiChatCompletionsObjectFromGemini(geminiResponse = {}, fallbac
   const usage = extractGeminiUsage(geminiResponse);
   const parsedContent = extractGeminiResponseContent(geminiResponse);
   const text = parsedContent.text;
+  const reasoningTokens = usage.reasoningTokens > 0
+    ? usage.reasoningTokens
+    : parsedContent.reasoningItems.reduce((acc, item) => acc + Math.floor((item.text || '').length / 4), 0);
   const model = geminiResponse.modelVersion || fallbackModel || '';
   const chatId = `chatcmpl_${Date.now()}`;
   const created = Math.floor(Date.now() / 1000);
@@ -1686,7 +2278,9 @@ function buildOpenAiChatCompletionsObjectFromGemini(geminiResponse = {}, fallbac
     usage: {
       prompt_tokens: usage.inputTokens,
       completion_tokens: usage.outputTokens,
-      total_tokens: usage.totalTokens
+      total_tokens: usage.totalTokens,
+      ...(usage.cachedTokens > 0 ? { prompt_tokens_details: { cached_tokens: usage.cachedTokens } } : {}),
+      ...(reasoningTokens > 0 ? { completion_tokens_details: { reasoning_tokens: reasoningTokens } } : {})
     }
   };
 }
@@ -1702,11 +2296,31 @@ function sendOpenAiStyleError(res, statusCode, message, type = 'invalid_request_
 }
 
 function publishOpenCodeUsageLog({ requestId, channel, model, usage, startTime }) {
-  const inputTokens = Number(usage?.input_tokens || usage?.prompt_tokens || 0);
-  const outputTokens = Number(usage?.output_tokens || usage?.completion_tokens || 0);
-  const totalTokens = Number(usage?.total_tokens || (inputTokens + outputTokens));
-  const cachedTokens = Number(usage?.input_tokens_details?.cached_tokens || 0);
-  const reasoningTokens = Number(usage?.output_tokens_details?.reasoning_tokens || 0);
+  // 兼容多种 usage 格式：
+  // - 标准 OpenAI/Anthropic 格式: {input_tokens, output_tokens} 或 {prompt_tokens, completion_tokens}
+  // - 网关内部格式 (relayChatCompletionsStream 等返回): {input, output, cacheCreation, cacheRead}
+  const inputTokens = Number(usage?.input_tokens || usage?.prompt_tokens || usage?.input || 0);
+  const outputTokens = Number(usage?.output_tokens || usage?.completion_tokens || usage?.output || 0);
+  const totalTokens = Number(usage?.total_tokens || usage?.total || (inputTokens + outputTokens));
+  const cacheReadTokens = Number(
+    usage?.input_tokens_details?.cached_tokens
+      || usage?.prompt_tokens_details?.cached_tokens
+      || usage?.providerMetadata?.anthropic?.cacheReadInputTokens
+      || usage?.cacheRead
+      || 0
+  );
+  const cacheCreationTokens = Number(
+    usage?.providerMetadata?.anthropic?.cacheCreationInputTokens
+      || usage?.cacheCreation
+      || 0
+  );
+  const cachedTokens = cacheReadTokens + cacheCreationTokens;
+  const reasoningTokens = Number(
+    usage?.output_tokens_details?.reasoning_tokens
+      || usage?.completion_tokens_details?.reasoning_tokens
+      || usage?.reasoning
+      || 0
+  );
   const now = new Date();
   const time = now.toLocaleTimeString('zh-CN', {
     hour12: false,
@@ -1718,7 +2332,9 @@ function publishOpenCodeUsageLog({ requestId, channel, model, usage, startTime }
   const tokens = {
     input: inputTokens,
     output: outputTokens,
-    total: totalTokens
+    total: totalTokens,
+    cacheRead: cacheReadTokens,
+    cacheCreation: cacheCreationTokens
   };
   const cost = calculateCost(model || '', tokens);
 
@@ -1824,10 +2440,57 @@ function sendResponsesSse(res, responseObject) {
   res.end();
 }
 
+function normalizeChatCompletionsDeltaToolCalls(toolCalls = []) {
+  if (!Array.isArray(toolCalls)) return [];
+
+  const normalizeIndex = (value, fallbackIndex) => {
+    if (typeof value === 'number' && Number.isInteger(value) && value >= 0) return value;
+    if (typeof value === 'string') {
+      const trimmed = value.trim();
+      if (/^\d+$/.test(trimmed)) return Number(trimmed);
+    }
+    return fallbackIndex;
+  };
+
+  const normalizedToolCalls = [];
+  let fallbackIndex = 0;
+
+  toolCalls.forEach(toolCall => {
+    if (!toolCall || typeof toolCall !== 'object') return;
+
+    const rawFunction = (toolCall.function && typeof toolCall.function === 'object')
+      ? toolCall.function
+      : {};
+    const fallbackName = typeof toolCall.name === 'string' ? toolCall.name : '';
+    const name = typeof rawFunction.name === 'string' ? rawFunction.name : fallbackName;
+    const rawArguments = Object.prototype.hasOwnProperty.call(rawFunction, 'arguments')
+      ? rawFunction.arguments
+      : toolCall.arguments;
+    const argumentsString = normalizeFunctionArgumentsString(
+      typeof rawArguments === 'string'
+        ? rawArguments
+        : JSON.stringify(rawArguments && typeof rawArguments === 'object' ? rawArguments : {})
+    );
+
+    normalizedToolCalls.push({
+      index: normalizeIndex(toolCall.index, fallbackIndex),
+      id: typeof toolCall.id === 'string' && toolCall.id.trim() ? toolCall.id.trim() : generateToolCallId(),
+      type: 'function',
+      function: {
+        name,
+        arguments: argumentsString
+      }
+    });
+    fallbackIndex += 1;
+  });
+
+  return normalizedToolCalls;
+}
+
 function sendChatCompletionsSse(res, responseObject) {
   const message = responseObject?.choices?.[0]?.message || {};
   const text = message?.content || '';
-  const toolCalls = Array.isArray(message?.tool_calls) ? message.tool_calls : [];
+  const toolCalls = normalizeChatCompletionsDeltaToolCalls(message?.tool_calls);
   const finishReason = responseObject?.choices?.[0]?.finish_reason || 'stop';
 
   setSseHeaders(res);
@@ -1865,6 +2528,21 @@ function sendChatCompletionsSse(res, responseObject) {
     ]
   };
   writeSseData(res, doneChunk);
+  // Match OpenAI stream_options.include_usage behavior: emit a final usage chunk.
+  writeSseData(res, {
+    id: responseObject.id,
+    object: 'chat.completion.chunk',
+    created: responseObject.created,
+    model: responseObject.model,
+    choices: [],
+    usage: responseObject?.usage && typeof responseObject.usage === 'object'
+      ? responseObject.usage
+      : {
+        prompt_tokens: 0,
+        completion_tokens: 0,
+        total_tokens: 0
+      }
+  });
   writeSseDone(res);
   res.end();
 }
@@ -1882,6 +2560,9 @@ function createClaudeResponsesStreamState(fallbackModel = '') {
     model: fallbackModel || '',
     inputTokens: 0,
     outputTokens: 0,
+    cachedTokens: 0,
+    cacheCreationTokens: 0,
+    cacheReadTokens: 0,
     usageSeen: false,
     blockTypeByIndex: new Map(),
     messageIdByIndex: new Map(),
@@ -2001,15 +2682,30 @@ function buildCompletedResponsesObjectFromStreamState(state) {
     output
   };
 
-  if (state.usageSeen || totalTokens > 0 || reasoningTokens > 0) {
-    response.usage = {
-      input_tokens: Number(state.inputTokens || 0),
-      output_tokens: Number(state.outputTokens || 0),
-      total_tokens: totalTokens
+  // 始终输出 usage 字段，确保 OpenCode Context 面板能正确读取 token 数据
+  response.usage = {
+    input_tokens: Number(state.inputTokens || 0),
+    output_tokens: Number(state.outputTokens || 0),
+    total_tokens: totalTokens
+  };
+  if (reasoningTokens > 0) {
+    response.usage.output_tokens_details = { reasoning_tokens: reasoningTokens };
+  }
+  if ((state.cacheReadTokens || 0) > 0) {
+    response.usage.input_tokens_details = { cached_tokens: Number(state.cacheReadTokens || 0) };
+  }
+  // 注入 providerMetadata.anthropic，供 OpenCode Session.getUsage() 读取 cache write/read tokens
+  if ((state.cacheCreationTokens || 0) > 0 || (state.cacheReadTokens || 0) > 0) {
+    response.providerMetadata = {
+      anthropic: {
+        ...(Number(state.cacheCreationTokens || 0) > 0
+          ? { cacheCreationInputTokens: Number(state.cacheCreationTokens || 0) }
+          : {}),
+        ...(Number(state.cacheReadTokens || 0) > 0
+          ? { cacheReadInputTokens: Number(state.cacheReadTokens || 0) }
+          : {})
+      }
     };
-    if (reasoningTokens > 0) {
-      response.usage.output_tokens_details = { reasoning_tokens: reasoningTokens };
-    }
   }
 
   return response;
@@ -2036,6 +2732,14 @@ function processClaudeResponsesSseEvent(parsed, state, res) {
         state.outputTokens = Number(message.usage.output_tokens);
         state.usageSeen = true;
       }
+      const cacheCreation = Number(message.usage.cache_creation_input_tokens || 0);
+      const cacheRead = Number(message.usage.cache_read_input_tokens || 0);
+      if (Number.isFinite(cacheCreation + cacheRead) && (cacheCreation + cacheRead) > 0) {
+        state.cacheCreationTokens = cacheCreation;
+        state.cacheReadTokens = cacheRead;
+        state.cachedTokens = cacheCreation + cacheRead;
+        state.usageSeen = true;
+      }
     }
 
     writeSseData(res, {
@@ -2345,7 +3049,7 @@ function processClaudeResponsesSseEvent(parsed, state, res) {
 
   if (type === 'message_delta') {
     const usage = parsed.usage && typeof parsed.usage === 'object' ? parsed.usage : {};
-    if (Number.isFinite(Number(usage.input_tokens))) {
+    if (Number.isFinite(Number(usage.input_tokens)) && Number(usage.input_tokens) > 0) {
       state.inputTokens = Number(usage.input_tokens);
       state.usageSeen = true;
     }
@@ -2353,6 +3057,14 @@ function processClaudeResponsesSseEvent(parsed, state, res) {
       state.outputTokens = Number(usage.output_tokens);
       state.usageSeen = true;
     }
+    const cacheCreation = Number(usage.cache_creation_input_tokens || 0);
+    const cacheRead = Number(usage.cache_read_input_tokens || 0);
+    if (Number.isFinite(cacheCreation + cacheRead) && (cacheCreation + cacheRead) > 0) {
+      state.cacheCreationTokens = cacheCreation;
+      state.cacheReadTokens = cacheRead;
+      state.cachedTokens = cacheCreation + cacheRead;
+      state.usageSeen = true;
+    }
     return;
   }
 
@@ -2687,6 +3399,253 @@ async function collectCodexResponsesNonStream(upstreamResponse, originalPayload
   });
 }
 
+async function relayChatCompletionsStream(upstreamResponse, res, fallbackModel = '') {
+  setSseHeaders(res);
+  const stream = createDecodedStream(upstreamResponse);
+
+  const chatId = `chatcmpl_${Date.now()}`;
+  const created = Math.floor(Date.now() / 1000);
+
+  // state tracked across SSE events
+  const state = {
+    model: fallbackModel || '',
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheCreationTokens: 0,
+    cacheReadTokens: 0,
+    stopReason: 'stop',
+    // per-block tracking
+    blockTypeByIndex: new Map(),
+    functionCallIdByIndex: new Map(),
+    functionNameByIndex: new Map(),
+    functionArgsByIndex: new Map(),
+    // tool_call index emitted to client (sequential, starting at 0)
+    toolCallClientIndexByBlockIndex: new Map(),
+    nextToolCallClientIndex: 0
+  };
+
+  return new Promise((resolve, reject) => {
+    let buffer = '';
+    let settled = false;
+
+    const safeResolve = (value) => { if (!settled) { settled = true; resolve(value); } };
+    const safeReject = (error) => { if (!settled) { settled = true; reject(error); } };
+
+    // Send the initial role chunk once
+    writeSseData(res, {
+      id: chatId,
+      object: 'chat.completion.chunk',
+      created,
+      model: state.model || fallbackModel,
+      choices: [{ index: 0, delta: { role: 'assistant', content: '' }, finish_reason: null }]
+    });
+
+    const processSseBlock = (block) => {
+      if (!block || !block.trim()) return;
+      const dataLines = block
+        .split('\n')
+        .map(line => line.trimEnd())
+        .filter(line => line.trim().startsWith('data:'))
+        .map(line => line.replace(/^data:\s?/, ''));
+      if (dataLines.length === 0) return;
+      const payload = dataLines.join('\n').trim();
+      if (!payload || payload === '[DONE]') return;
+
+      let parsed;
+      try { parsed = JSON.parse(payload); } catch { return; }
+      if (!parsed || typeof parsed !== 'object') return;
+
+      const type = parsed.type;
+      if (!type) return;
+
+      if (type === 'message_start') {
+        const msg = parsed.message && typeof parsed.message === 'object' ? parsed.message : {};
+        if (msg.model) state.model = msg.model;
+        if (msg.usage) {
+          state.inputTokens = Number(msg.usage.input_tokens || 0);
+          state.cacheCreationTokens = Number(msg.usage.cache_creation_input_tokens || 0);
+          state.cacheReadTokens = Number(msg.usage.cache_read_input_tokens || 0);
+        }
+        return;
+      }
+
+      if (type === 'content_block_start') {
+        const blockIndex = Number.isFinite(Number(parsed.index)) ? Number(parsed.index) : 0;
+        const block = parsed.content_block && typeof parsed.content_block === 'object' ? parsed.content_block : {};
+        const blockType = block.type;
+        state.blockTypeByIndex.set(blockIndex, blockType);
+
+        if (blockType === 'tool_use') {
+          const callId = String(block.id || generateToolCallId());
+          const name = block.name || '';
+          state.functionCallIdByIndex.set(blockIndex, callId);
+          state.functionNameByIndex.set(blockIndex, name);
+          state.functionArgsByIndex.set(blockIndex, '');
+          const clientIndex = state.nextToolCallClientIndex++;
+          state.toolCallClientIndexByBlockIndex.set(blockIndex, clientIndex);
+
+          // Emit tool_call start chunk
+          writeSseData(res, {
+            id: chatId,
+            object: 'chat.completion.chunk',
+            created,
+            model: state.model || fallbackModel,
+            choices: [{
+              index: 0,
+              delta: {
+                tool_calls: [{
+                  index: clientIndex,
+                  id: callId,
+                  type: 'function',
+                  function: { name, arguments: '' }
+                }]
+              },
+              finish_reason: null
+            }]
+          });
+        }
+        return;
+      }
+
+      if (type === 'content_block_delta') {
+        const blockIndex = Number.isFinite(Number(parsed.index)) ? Number(parsed.index) : 0;
+        const delta = parsed.delta && typeof parsed.delta === 'object' ? parsed.delta : {};
+        const deltaType = delta.type;
+
+        if (deltaType === 'text_delta') {
+          const text = typeof delta.text === 'string' ? delta.text : '';
+          if (!text) return;
+          writeSseData(res, {
+            id: chatId,
+            object: 'chat.completion.chunk',
+            created,
+            model: state.model || fallbackModel,
+            choices: [{ index: 0, delta: { content: text }, finish_reason: null }]
+          });
+          return;
+        }
+
+        if (deltaType === 'input_json_delta') {
+          const partialJson = typeof delta.partial_json === 'string' ? delta.partial_json : '';
+          if (!partialJson) return;
+          const prev = state.functionArgsByIndex.get(blockIndex) || '';
+          state.functionArgsByIndex.set(blockIndex, prev + partialJson);
+          const clientIndex = state.toolCallClientIndexByBlockIndex.get(blockIndex) ?? 0;
+          writeSseData(res, {
+            id: chatId,
+            object: 'chat.completion.chunk',
+            created,
+            model: state.model || fallbackModel,
+            choices: [{
+              index: 0,
+              delta: {
+                tool_calls: [{
+                  index: clientIndex,
+                  function: { arguments: partialJson }
+                }]
+              },
+              finish_reason: null
+            }]
+          });
+          return;
+        }
+        // thinking_delta: silently skip (no equivalent in chat completions)
+        return;
+      }
+
+      if (type === 'message_delta') {
+        const usage = parsed.usage && typeof parsed.usage === 'object' ? parsed.usage : {};
+        if (Number.isFinite(Number(usage.output_tokens))) {
+          state.outputTokens = Number(usage.output_tokens);
+        }
+        const stopReason = parsed.delta && parsed.delta.stop_reason;
+        if (stopReason) state.stopReason = stopReason;
+        return;
+      }
+
+      if (type === 'message_stop') {
+        const finishReason = mapClaudeStopReasonToChatFinishReason(state.stopReason);
+        const hasToolCalls = state.nextToolCallClientIndex > 0;
+
+        // Final finish chunk
+        writeSseData(res, {
+          id: chatId,
+          object: 'chat.completion.chunk',
+          created,
+          model: state.model || fallbackModel,
+          choices: [{ index: 0, delta: {}, finish_reason: hasToolCalls ? 'tool_calls' : finishReason }]
+        });
+
+        // Usage chunk (stream_options.include_usage)
+        const inputTokens = state.inputTokens;
+        const outputTokens = state.outputTokens;
+        const cachedTokens = state.cacheCreationTokens + state.cacheReadTokens;
+        writeSseData(res, {
+          id: chatId,
+          object: 'chat.completion.chunk',
+          created,
+          model: state.model || fallbackModel,
+          choices: [],
+          usage: {
+            prompt_tokens: inputTokens,
+            completion_tokens: outputTokens,
+            total_tokens: inputTokens + outputTokens,
+            ...(cachedTokens > 0 ? { prompt_tokens_details: { cached_tokens: cachedTokens } } : {})
+          }
+        });
+
+        writeSseDone(res);
+        res.end();
+        safeResolve({
+          model: state.model || fallbackModel,
+          usage: {
+            input: inputTokens,
+            output: outputTokens,
+            cacheCreation: state.cacheCreationTokens,
+            cacheRead: state.cacheReadTokens
+          }
+        });
+      }
+    };
+
+    stream.on('data', (chunk) => {
+      buffer += chunk.toString('utf8').replace(/\r\n/g, '\n');
+      let separatorIndex = buffer.indexOf('\n\n');
+      while (separatorIndex >= 0) {
+        const block = buffer.slice(0, separatorIndex);
+        buffer = buffer.slice(separatorIndex + 2);
+        processSseBlock(block);
+        separatorIndex = buffer.indexOf('\n\n');
+      }
+    });
+
+    stream.on('end', () => {
+      if (buffer.trim()) processSseBlock(buffer);
+      if (!res.writableEnded) {
+        writeSseDone(res);
+        res.end();
+      }
+      safeResolve({ model: state.model || fallbackModel, usage: { input: state.inputTokens, output: state.outputTokens, cacheCreation: state.cacheCreationTokens, cacheRead: state.cacheReadTokens } });
+    });
+
+    stream.on('error', (error) => {
+      if (!res.writableEnded) {
+        writeSseDone(res);
+        res.end();
+      }
+      safeReject(error);
+    });
+
+    upstreamResponse.on('error', (error) => {
+      if (!res.writableEnded) {
+        writeSseDone(res);
+        res.end();
+      }
+      safeReject(error);
+    });
+  });
+}
+
 async function handleClaudeGatewayRequest(req, res, channel, effectiveKey) {
   const pathname = getRequestPathname(req.url);
   if (!isResponsesPath(pathname) && !isChatCompletionsPath(pathname)) {
@@ -2703,6 +3662,7 @@ async function handleClaudeGatewayRequest(req, res, channel, effectiveKey) {
   const originalPayload = (req.body && typeof req.body === 'object') ? req.body : {};
   const wantsStream = !!originalPayload.stream;
   const streamResponses = wantsStream && isResponsesPath(pathname);
+  const streamChatCompletions = wantsStream && isChatCompletionsPath(pathname);
   const sessionKey = extractSessionIdFromRequest(req, originalPayload);
   const sessionScope = normalizeSessionKeyValue(channel?.id || channel?.name || '');
   const scopedSessionKey = sessionKey && sessionScope
@@ -2713,7 +3673,7 @@ async function handleClaudeGatewayRequest(req, res, channel, effectiveKey) {
   const claudePayload = convertOpenCodePayloadToClaude(pathname, originalPayload, channel.model, {
     sessionUserId
   });
-  claudePayload.stream = streamResponses;
+  claudePayload.stream = streamResponses || streamChatCompletions;
 
   const headers = {
     'x-api-key': effectiveKey,
@@ -2732,12 +3692,61 @@ async function handleClaudeGatewayRequest(req, res, channel, effectiveKey) {
     'x-stainless-os': mapStainlessOs(),
     'x-stainless-timeout': '600',
     'content-type': 'application/json',
-    'accept': streamResponses ? 'text/event-stream' : 'application/json',
+    'accept': (streamResponses || streamChatCompletions) ? 'text/event-stream' : 'application/json',
     'accept-encoding': 'gzip, deflate, br, zstd',
     'connection': 'keep-alive',
     'user-agent': CLAUDE_CODE_USER_AGENT
   };
 
+  if (streamChatCompletions) {
+    let streamUpstream;
+    try {
+      streamUpstream = await postJsonStream(buildClaudeTargetUrl(channel.baseUrl), headers, claudePayload, 120000);
+    } catch (error) {
+      recordFailure(channel.id, 'opencode', error);
+      sendOpenAiStyleError(res, 502, `Claude gateway network error: ${error.message}`, 'proxy_error');
+      return true;
+    }
+
+    const statusCode = Number(streamUpstream.statusCode) || 500;
+    if (statusCode < 200 || statusCode >= 300) {
+      let rawBody = '';
+      try {
+        rawBody = await collectHttpResponseBody(streamUpstream.response);
+      } catch {
+        rawBody = '';
+      }
+      let parsedError = null;
+      try {
+        parsedError = rawBody ? JSON.parse(rawBody) : null;
+      } catch {
+        parsedError = null;
+      }
+      const upstreamMessage = parsedError?.error?.message || parsedError?.message || rawBody || `HTTP ${statusCode}`;
+      recordFailure(channel.id, 'opencode', new Error(String(upstreamMessage).slice(0, 200)));
+      sendOpenAiStyleError(res, statusCode, String(upstreamMessage).slice(0, 1000), 'upstream_error');
+      return true;
+    }
+
+    try {
+      const streamedResponseObject = await relayChatCompletionsStream(streamUpstream.response, res, originalPayload.model || '');
+      publishOpenCodeUsageLog({
+        requestId,
+        channel,
+        model: streamedResponseObject?.model || originalPayload.model || '',
+        usage: streamedResponseObject?.usage || {},
+        startTime
+      });
+      recordSuccess(channel.id, 'opencode');
+    } catch (error) {
+      recordFailure(channel.id, 'opencode', error);
+      if (!res.headersSent) {
+        sendOpenAiStyleError(res, 502, `Claude stream relay error: ${error.message}`, 'proxy_error');
+      }
+    }
+    return true;
+  }
+
   if (streamResponses) {
     let streamUpstream;
     try {
@@ -2775,7 +3784,9 @@ async function handleClaudeGatewayRequest(req, res, channel, effectiveKey) {
         requestId,
         channel,
         model: streamedResponseObject?.model || originalPayload.model || '',
-        usage: streamedResponseObject?.usage || {},
+        usage: streamedResponseObject?.providerMetadata
+          ? { ...(streamedResponseObject.usage || {}), providerMetadata: streamedResponseObject.providerMetadata }
+          : streamedResponseObject?.usage || {},
         startTime
       });
       recordSuccess(channel.id, 'opencode');
@@ -2882,10 +3893,11 @@ async function handleCodexGatewayRequest(req, res, channel, effectiveKey) {
     return true;
   }
 
-  const codexSessionId = `${Date.now()}-${Math.random().toString(36).slice(2, 15)}`;
+  const codexSessionId = extractSessionIdFromRequest(req, originalPayload);
+  const stableSessionKey = codexSessionId || `${channel.id || 'ch'}-${channel.baseUrl || ''}`;
   const promptCacheKey = (typeof converted.requestBody.prompt_cache_key === 'string' && converted.requestBody.prompt_cache_key.trim())
     ? converted.requestBody.prompt_cache_key.trim()
-    : codexSessionId;
+    : stableSessionKey;
   converted.requestBody.prompt_cache_key = promptCacheKey;
 
   const headers = {
@@ -3814,21 +4826,36 @@ async function collectProxyModelList(channels = [], options = {}) {
   };
 
   const forceRefresh = options.forceRefresh === true;
+  const probePreferredModels = options.probePreferredModels === true;
+  const useCacheOnly = options.useCacheOnly === true;
   // 模型列表聚合改为串行探测，避免并发触发上游会话窗口限流
   for (const channel of channels) {
+    if (useCacheOnly) {
+      const cacheEntry = getCachedModelInfo(channel?.id);
+      const cachedFetched = Array.isArray(cacheEntry?.fetchedModels) ? cacheEntry.fetchedModels : [];
+      const cachedAvailable = Array.isArray(cacheEntry?.availableModels) ? cacheEntry.availableModels : [];
+      cachedFetched.forEach(add);
+      cachedAvailable.forEach(add);
+      continue;
+    }
+
     try {
       // eslint-disable-next-line no-await-in-loop
       const listResult = await fetchModelsFromProvider(channel, 'openai_compatible', { forceRefresh });
       const listedModels = Array.isArray(listResult?.models) ? listResult.models : [];
       if (listedModels.length > 0) {
         listedModels.forEach(add);
-        continue;
+        // 默认沿用 /v1/models 结果；仅在显式要求时继续探测默认模型。
+        if (!probePreferredModels) {
+          continue;
+        }
       }
 
       const shouldProbeByDefault = !!listResult?.disabledByConfig;
 
-      // 默认仅入口转换器渠道执行模型探测；若已禁用 /v1/models 则对全部渠道启用默认探测
-      if (!shouldProbeByDefault && !isConverterPresetChannel(channel)) {
+      // 默认仅入口转换器渠道执行模型探测；若已禁用 /v1/models 则对全部渠道启用默认探测。
+      // 当显式要求 probePreferredModels 时，无论 /v1/models 是否返回都执行默认模型探测。
+      if (!probePreferredModels && !shouldProbeByDefault && !isConverterPresetChannel(channel)) {
         continue;
       }
 
@@ -3837,6 +4864,7 @@ async function collectProxyModelList(channels = [], options = {}) {
       const probe = await probeModelAvailability(channel, channelType, {
         forceRefresh,
         stopOnFirstAvailable: false,
+        toolType: 'opencode',
         preferredModels: collectPreferredProbeModels(channel)
       });
       const available = Array.isArray(probe?.availableModels) ? probe.availableModels : [];
@@ -3906,11 +4934,23 @@ async function startOpenCodeProxyServer(options = {}) {
       if (!proxyReq.getHeader('content-type')) {
         proxyReq.setHeader('content-type', 'application/json');
       }
+      // 禁止上游返回压缩响应，避免在 proxyRes 监听器中出现双消费者竞争
+      proxyReq.removeHeader('accept-encoding');
 
       if (shouldParseJson(req) && (req.rawBody || req.body)) {
-        const bodyBuffer = req.rawBody
-          ? Buffer.isBuffer(req.rawBody) ? req.rawBody : Buffer.from(req.rawBody)
-          : Buffer.from(JSON.stringify(req.body));
+        let body = req.body;
+        // 对 Chat Completions 流式请求注入 stream_options.include_usage = true
+        // OpenCode 使用 @ai-sdk/openai-compatible，该 SDK 不一定发送此字段
+        // 缺少此字段时，大多数 OpenAI 兼容端点不会在响应中附带 usage，
+        // 导致 OpenCode Context 面板所有 token 显示为 0
+        if (body && body.stream === true && !body.stream_options?.include_usage) {
+          body = { ...body, stream_options: { ...body.stream_options, include_usage: true } };
+        }
+        const bodyBuffer = body !== req.body
+          ? Buffer.from(JSON.stringify(body))
+          : req.rawBody
+            ? Buffer.isBuffer(req.rawBody) ? req.rawBody : Buffer.from(req.rawBody)
+            : Buffer.from(JSON.stringify(req.body));
         proxyReq.setHeader('Content-Length', bodyBuffer.length);
         proxyReq.write(bodyBuffer);
         proxyReq.end();
@@ -4087,18 +5127,23 @@ async function startOpenCodeProxyServer(options = {}) {
         inputTokens: 0,
         outputTokens: 0,
         cachedTokens: 0,
+        cacheCreationTokens: 0,
+        cacheReadTokens: 0,
         reasoningTokens: 0,
         totalTokens: 0,
-        model: ''
+        model: '',
+        _parseErrorLogged: false
       };
 
-      proxyRes.on('data', (chunk) => {
+      const decodedStream = createDecodedStream(proxyRes);
+
+      decodedStream.on('data', (chunk) => {
         // 如果响应已关闭，停止处理
         if (isResponseClosed) {
           return;
         }
 
-        buffer += chunk.toString();
+        buffer += chunk.toString('utf8');
 
         // 检查是否是 SSE 流
         if (proxyRes.headers['content-type']?.includes('text/event-stream')) {
@@ -4106,7 +5151,7 @@ async function startOpenCodeProxyServer(options = {}) {
           const events = buffer.split('\n\n');
           buffer = events.pop() || '';
 
-          events.forEach((eventText, index) => {
+          events.forEach((eventText) => {
             if (!eventText.trim()) return;
 
             try {
@@ -4127,7 +5172,6 @@ async function startOpenCodeProxyServer(options = {}) {
 
               // OpenAI Responses API: 在 response.completed 事件中获取 usage
               if (parsed.type === 'response.completed' && parsed.response) {
-                // 从 response 对象中提取模型和 usage
                 if (parsed.response.model) {
                   tokenData.model = parsed.response.model;
                 }
@@ -4137,7 +5181,6 @@ async function startOpenCodeProxyServer(options = {}) {
                   tokenData.outputTokens = parsed.response.usage.output_tokens || 0;
                   tokenData.totalTokens = parsed.response.usage.total_tokens || 0;
 
-                  // 提取详细信息
                   if (parsed.response.usage.input_tokens_details) {
                     tokenData.cachedTokens = parsed.response.usage.input_tokens_details.cached_tokens || 0;
                   }
@@ -4147,24 +5190,81 @@ async function startOpenCodeProxyServer(options = {}) {
                 }
               }
 
+              // Anthropic SSE: message_start 含初始 usage 和模型
+              if (parsed.type === 'message_start' && parsed.message) {
+                if (parsed.message.model) {
+                  tokenData.model = parsed.message.model;
+                }
+                if (parsed.message.usage) {
+                  const u = parsed.message.usage;
+                  if (Number.isFinite(Number(u.input_tokens))) {
+                    tokenData.inputTokens = Number(u.input_tokens);
+                  }
+                  if (Number.isFinite(Number(u.output_tokens))) {
+                    tokenData.outputTokens = Number(u.output_tokens);
+                  }
+                  const cacheCreation = Number(u.cache_creation_input_tokens || 0);
+                  const cacheRead = Number(u.cache_read_input_tokens || 0);
+                  if (cacheCreation + cacheRead > 0) {
+                    tokenData.cacheCreationTokens = cacheCreation;
+                    tokenData.cacheReadTokens = cacheRead;
+                    tokenData.cachedTokens = cacheCreation + cacheRead;
+                  }
+                }
+              }
+
+              // Anthropic SSE: message_delta 含最终 output_tokens
+              if (parsed.type === 'message_delta' && parsed.usage) {
+                const u = parsed.usage;
+                if (Number.isFinite(Number(u.output_tokens))) {
+                  tokenData.outputTokens = Number(u.output_tokens);
+                }
+                const cacheCreation = Number(u.cache_creation_input_tokens || 0);
+                const cacheRead = Number(u.cache_read_input_tokens || 0);
+                if (cacheCreation + cacheRead > 0) {
+                  tokenData.cacheCreationTokens = cacheCreation;
+                  tokenData.cacheReadTokens = cacheRead;
+                  tokenData.cachedTokens = cacheCreation + cacheRead;
+                }
+              }
+
               // 兼容其他格式：直接在顶层的 model 和 usage
               if (parsed.model && !tokenData.model) {
                 tokenData.model = parsed.model;
               }
 
               if (parsed.usage && tokenData.inputTokens === 0) {
-                // 兼容 Responses API 和 Chat Completions API
                 tokenData.inputTokens = parsed.usage.input_tokens || parsed.usage.prompt_tokens || 0;
                 tokenData.outputTokens = parsed.usage.output_tokens || parsed.usage.completion_tokens || 0;
+                const cacheCreation = Number(parsed.usage.cache_creation_input_tokens || 0);
+                const cacheRead = Number(parsed.usage.cache_read_input_tokens || 0);
+                if (cacheCreation + cacheRead > 0) {
+                  tokenData.cacheCreationTokens = cacheCreation;
+                  tokenData.cacheReadTokens = cacheRead;
+                  tokenData.cachedTokens = cacheCreation + cacheRead;
+                }
+              }
+
+              // Gemini SSE: usageMetadata
+              if (parsed.usageMetadata) {
+                const u = parsed.usageMetadata;
+                tokenData.inputTokens = Number(u.promptTokenCount || 0);
+                tokenData.outputTokens = Number(u.candidatesTokenCount || 0);
+                tokenData.cachedTokens = Number(u.cachedContentTokenCount || 0);
+                tokenData.totalTokens = Number(u.totalTokenCount || 0);
               }
             } catch (err) {
-              // 忽略解析错误
+              if (!tokenData._parseErrorLogged) {
+                tokenData._parseErrorLogged = true;
+                const snippet = typeof data === 'string' ? data.slice(0, 100) : '';
+                console.warn(`[OpenCode Passthrough] SSE parse error (channel: ${metadata?.channel}): ${err.message}, data: ${snippet}`);
+              }
             }
           });
         }
       });
 
-      proxyRes.on('end', () => {
+      decodedStream.on('end', () => {
         // 如果不是流式响应，尝试从完整响应中解析
         if (!proxyRes.headers['content-type']?.includes('text/event-stream')) {
           try {
@@ -4173,12 +5273,21 @@ async function startOpenCodeProxyServer(options = {}) {
               tokenData.model = parsed.model;
             }
             if (parsed.usage) {
-              // 兼容两种格式
               tokenData.inputTokens = parsed.usage.input_tokens || parsed.usage.prompt_tokens || 0;
               tokenData.outputTokens = parsed.usage.output_tokens || parsed.usage.completion_tokens || 0;
+              const cacheCreation = Number(parsed.usage.cache_creation_input_tokens || 0);
+              const cacheRead = Number(parsed.usage.cache_read_input_tokens || 0);
+              if (cacheCreation + cacheRead > 0) {
+                tokenData.cacheCreationTokens = cacheCreation;
+                tokenData.cacheReadTokens = cacheRead;
+                tokenData.cachedTokens = cacheCreation + cacheRead;
+              }
             }
           } catch (err) {
-            // 忽略解析错误
+            if (!tokenData._parseErrorLogged) {
+              tokenData._parseErrorLogged = true;
+              console.warn(`[OpenCode Passthrough] Non-SSE response parse error (channel: ${metadata?.channel}): ${err.message}`);
+            }
           }
         }
 
@@ -4196,7 +5305,9 @@ async function startOpenCodeProxyServer(options = {}) {
           const tokens = {
             input: tokenData.inputTokens,
             output: tokenData.outputTokens,
-            total: tokenData.inputTokens + tokenData.outputTokens
+            cacheCreation: tokenData.cacheCreationTokens,
+            cacheRead: tokenData.cacheReadTokens,
+            total: tokenData.totalTokens || (tokenData.inputTokens + tokenData.outputTokens)
           };
           const cost = calculateCost(tokenData.model, tokens);
 
@@ -4247,7 +5358,7 @@ async function startOpenCodeProxyServer(options = {}) {
         }
       });
 
-      proxyRes.on('error', (err) => {
+      decodedStream.on('error', (err) => {
         // 忽略代理响应错误（可能是网络问题）
         if (err.code !== 'EPIPE' && err.code !== 'ECONNRESET') {
           console.error('Proxy response error:', err);