coding-tool-x 3.5.11 → 3.5.13

package/src/server/services/base/response-usage-parser.js

@@ -8,6 +8,128 @@
  * 并确保模型重定向后仍能正确解析不同格式的响应。
  */
 
+function readNumericField(source, keys = []) {
+  for (const key of keys) {
+    if (!source || source[key] === undefined || source[key] === null) {
+      continue;
+    }
+    const value = Number(source[key]);
+    if (Number.isFinite(value)) {
+      return value;
+    }
+  }
+  return undefined;
+}
+
+function readNestedNumericField(source, pathVariants = []) {
+  for (const path of pathVariants) {
+    let current = source;
+    let missing = false;
+    for (const segment of path) {
+      if (!current || typeof current !== 'object' || !(segment in current)) {
+        missing = true;
+        break;
+      }
+      current = current[segment];
+    }
+    if (missing || current === undefined || current === null) {
+      continue;
+    }
+    const value = Number(current);
+    if (Number.isFinite(value)) {
+      return value;
+    }
+  }
+  return undefined;
+}
+
+function parseUsageObject(rawUsage) {
+  if (!rawUsage || typeof rawUsage !== 'object') {
+    return null;
+  }
+
+  const tokens = {};
+  const hasAnthropicCacheFields =
+    rawUsage.cache_creation_input_tokens !== undefined ||
+    rawUsage.cache_read_input_tokens !== undefined ||
+    rawUsage.cacheCreationInputTokens !== undefined ||
+    rawUsage.cacheReadInputTokens !== undefined;
+  const hasOpenAiPromptFields =
+    rawUsage.prompt_tokens !== undefined ||
+    rawUsage.promptTokens !== undefined ||
+    rawUsage.prompt_tokens_details !== undefined ||
+    rawUsage.promptTokensDetails !== undefined;
+  const hasOpenAiResponseFields =
+    rawUsage.input_tokens_details !== undefined ||
+    rawUsage.inputTokensDetails !== undefined ||
+    rawUsage.output_tokens_details !== undefined ||
+    rawUsage.outputTokensDetails !== undefined;
+  const hasOpenAiCompatibilityFields =
+    hasOpenAiPromptFields ||
+    hasOpenAiResponseFields ||
+    rawUsage.cached_tokens !== undefined ||
+    rawUsage.cachedTokens !== undefined ||
+    rawUsage.reasoning_tokens !== undefined ||
+    rawUsage.reasoningTokens !== undefined ||
+    rawUsage.completion_tokens_details !== undefined ||
+    rawUsage.completionTokensDetails !== undefined;
+
+  const input = readNumericField(rawUsage, ['input_tokens', 'prompt_tokens', 'inputTokens', 'promptTokens']);
+  if (input !== undefined) tokens.input = input;
+
+  const output = readNumericField(rawUsage, ['output_tokens', 'completion_tokens', 'outputTokens', 'completionTokens']);
+  if (output !== undefined) tokens.output = output;
+
+  const total = readNumericField(rawUsage, ['total_tokens', 'totalTokens']);
+  if (total !== undefined) tokens.total = total;
+
+  const cacheCreation = readNumericField(rawUsage, ['cache_creation_input_tokens', 'cacheCreationInputTokens'])
+    ?? readNestedNumericField(rawUsage, [
+      ['prompt_tokens_details', 'cache_creation_input_tokens'],
+      ['promptTokensDetails', 'cacheCreationInputTokens']
+    ]);
+  if (cacheCreation !== undefined) tokens.cacheCreation = cacheCreation;
+
+  const cacheRead = readNumericField(rawUsage, ['cache_read_input_tokens', 'cacheReadInputTokens']);
+  if (cacheRead !== undefined) tokens.cacheRead = cacheRead;
+
+  const cached = readNumericField(rawUsage, ['cached_tokens', 'cachedTokens'])
+    ?? readNestedNumericField(rawUsage, [
+      ['input_tokens_details', 'cached_tokens'],
+      ['prompt_tokens_details', 'cached_tokens'],
+      ['inputTokensDetails', 'cachedTokens'],
+      ['promptTokensDetails', 'cachedTokens']
+    ]);
+  if (cached !== undefined) tokens.cached = cached;
+
+  const reasoning = readNumericField(rawUsage, ['reasoning_tokens', 'reasoningTokens'])
+    ?? readNestedNumericField(rawUsage, [
+      ['completion_tokens_details', 'reasoning_tokens'],
+      ['output_tokens_details', 'reasoning_tokens'],
+      ['completionTokensDetails', 'reasoningTokens'],
+      ['outputTokensDetails', 'reasoningTokens']
+    ]);
+  if (reasoning !== undefined) tokens.reasoning = reasoning;
+
+  if (tokens.total === undefined && tokens.input !== undefined && tokens.output !== undefined && !hasAnthropicCacheFields) {
+    tokens.total = tokens.input + tokens.output;
+  }
+
+  // OpenAI/OpenAI-compatible usage commonly reports prompt/input totals that
+  // already include cache hits. Align with OpenCode's provider contract by
+  // moving cached prompt tokens into a dedicated field and keeping input as the
+  // net uncached prompt tokens.
+  if (!hasAnthropicCacheFields && hasOpenAiCompatibilityFields && tokens.cached !== undefined && tokens.input !== undefined) {
+    tokens.input = Math.max(tokens.input - tokens.cached, 0);
+  }
+
+  if (Object.keys(tokens).length === 0) {
+    return null;
+  }
+
+  return tokens;
+}
+
 /**
  * 从单个 SSE 事件的 parsed JSON 中提取 model 和 token 信息。
  * 自动检测 Claude / OpenAI / Gemini 格式。
@@ -31,82 +153,35 @@ function parseSSEUsage(parsed, eventType) {
   if (eventType === 'message_start' && parsed.message && parsed.message.model) {
     model = parsed.message.model;
   }
+  if (!tokens && parsed.message && parsed.message.usage) {
+    tokens = parseUsageObject(parsed.message.usage);
+  }
   if (eventType === 'message_stop') {
     isDone = true;
   }
 
   // === OpenAI Responses API 格式 ===
   // data: {"type": "response.completed", "response": {"model", "usage": {...}}}
-  if (parsed.type === 'response.completed' && parsed.response) {
+  if ((parsed.type === 'response.completed' || parsed.type === 'response.incomplete') && parsed.response) {
     if (parsed.response.model) {
       model = parsed.response.model;
     }
     if (parsed.response.usage) {
-      tokens = {
-        input: parsed.response.usage.input_tokens || 0,
-        output: parsed.response.usage.output_tokens || 0,
-        total: parsed.response.usage.total_tokens || 0,
-      };
-      if (parsed.response.usage.input_tokens_details &&
-          parsed.response.usage.input_tokens_details.cached_tokens !== undefined) {
-        tokens.cached = parsed.response.usage.input_tokens_details.cached_tokens;
-      }
-      if (parsed.response.usage.output_tokens_details &&
-          parsed.response.usage.output_tokens_details.reasoning_tokens !== undefined) {
-        tokens.reasoning = parsed.response.usage.output_tokens_details.reasoning_tokens;
-      }
+      tokens = parseUsageObject(parsed.response.usage);
     }
     isDone = true;
   }
 
   // === parsed.usage（Claude 原生 + OpenAI Chat Completions 共用） ===
   if (!tokens && parsed.usage) {
-    const t = {};
-
-    // Claude 格式字段
-    if (parsed.usage.input_tokens !== undefined) {
-      t.input = parsed.usage.input_tokens;
-    }
-    if (parsed.usage.output_tokens !== undefined) {
-      t.output = parsed.usage.output_tokens;
-    }
-    if (parsed.usage.cache_creation_input_tokens !== undefined) {
-      t.cacheCreation = parsed.usage.cache_creation_input_tokens;
-    }
-    if (parsed.usage.cache_read_input_tokens !== undefined) {
-      t.cacheRead = parsed.usage.cache_read_input_tokens;
-    }
-
-    // OpenAI Chat Completions 格式字段（fallback）
-    if (t.input === undefined && parsed.usage.prompt_tokens !== undefined) {
-      t.input = parsed.usage.prompt_tokens;
-    }
-    if (t.output === undefined && parsed.usage.completion_tokens !== undefined) {
-      t.output = parsed.usage.completion_tokens;
-    }
-    if (parsed.usage.total_tokens !== undefined) {
-      t.total = parsed.usage.total_tokens;
-    }
-
-    // OpenAI detailed breakdowns
-    if (parsed.usage.input_tokens_details &&
-        parsed.usage.input_tokens_details.cached_tokens !== undefined) {
-      t.cached = parsed.usage.input_tokens_details.cached_tokens;
-    }
-    if (parsed.usage.output_tokens_details &&
-        parsed.usage.output_tokens_details.reasoning_tokens !== undefined) {
-      t.reasoning = parsed.usage.output_tokens_details.reasoning_tokens;
-    }
-
-    // Gemini cache in OpenAI compat mode
-    if (parsed.usage.prompt_tokens_details &&
-        parsed.usage.prompt_tokens_details.cached_tokens !== undefined) {
-      t.cached = parsed.usage.prompt_tokens_details.cached_tokens;
-    }
+    tokens = parseUsageObject(parsed.usage);
+  }
 
-    if (Object.keys(t).length > 0) {
-      tokens = t;
-    }
+  if (!tokens && parsed.tokenUsage) {
+    tokens = parseUsageObject(parsed.tokenUsage);
+  }
+  if (!tokens && parsed.token_usage) {
+    tokens = parseUsageObject(parsed.token_usage);
   }
 
   // === Gemini Native 格式 ===
@@ -120,6 +195,9 @@ function parseSSEUsage(parsed, eventType) {
     if (parsed.usageMetadata.cachedContentTokenCount) {
       tokens.cached = parsed.usageMetadata.cachedContentTokenCount;
     }
+    if (parsed.usageMetadata.thoughtsTokenCount) {
+      tokens.reasoning = parsed.usageMetadata.thoughtsTokenCount;
+    }
   }
 
   // === 通用 model fallback ===

package/src/server/services/codex-statistics-service.js

@@ -110,6 +110,7 @@ function recordRequest(requestData = {}) {
       input: normalizedTokens.input,
       output: normalizedTokens.output,
       reasoning: normalizedTokens.reasoning,
+      cached: normalizedTokens.cached,
       cacheCreation: normalizedTokens.cacheCreation,
       cacheRead: normalizedTokens.cacheRead,
       total: normalizedTokens.total

package/src/server/services/gemini-statistics-service.js

@@ -108,6 +108,7 @@ function recordRequest(requestData = {}) {
     tokens: {
       input: normalizedTokens.input,
       output: normalizedTokens.output,
+      cached: normalizedTokens.cached,
       cacheCreation: normalizedTokens.cacheCreation,
       cacheRead: normalizedTokens.cacheRead,
       total: normalizedTokens.total

package/src/server/services/https-cert.js

@@ -0,0 +1,202 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const { randomBytes } = require('crypto');
+const { PATHS } = require('../../config/paths');
+
+const HTTPS_DIR = path.join(PATHS.config, 'https');
+const HTTPS_KEY_FILE = path.join(HTTPS_DIR, 'localhost-key.pem');
+const HTTPS_CERT_FILE = path.join(HTTPS_DIR, 'localhost-cert.pem');
+const HTTPS_PFX_FILE = path.join(HTTPS_DIR, 'localhost.pfx');
+const HTTPS_META_FILE = path.join(HTTPS_DIR, 'meta.json');
+
+function ensureHttpsDir() {
+  if (!fs.existsSync(HTTPS_DIR)) {
+    fs.mkdirSync(HTTPS_DIR, { recursive: true });
+  }
+}
+
+function readMeta() {
+  if (!fs.existsSync(HTTPS_META_FILE)) {
+    return {};
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(HTTPS_META_FILE, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function writeMeta(meta) {
+  ensureHttpsDir();
+  fs.writeFileSync(HTTPS_META_FILE, JSON.stringify(meta, null, 2), 'utf8');
+}
+
+function resolveOpenSslCommand() {
+  const commands = process.platform === 'win32'
+    ? ['openssl.exe', 'openssl']
+    : ['openssl'];
+
+  for (const command of commands) {
+    try {
+      execFileSync(command, ['version'], { stdio: 'ignore' });
+      return command;
+    } catch {
+      // Try next candidate.
+    }
+  }
+
+  return '';
+}
+
+function buildOpenSslConfig() {
+  return [
+    '[req]',
+    'default_bits = 2048',
+    'distinguished_name = req_distinguished_name',
+    'prompt = no',
+    'x509_extensions = v3_req',
+    '',
+    '[req_distinguished_name]',
+    'CN = localhost',
+    '',
+    '[v3_req]',
+    'subjectAltName = @alt_names',
+    'keyUsage = digitalSignature, keyEncipherment',
+    'extendedKeyUsage = serverAuth',
+    '',
+    '[alt_names]',
+    'DNS.1 = localhost',
+    'IP.1 = 127.0.0.1',
+    'IP.2 = ::1'
+  ].join('\n');
+}
+
+function generatePemCertificateWithOpenSsl(command) {
+  ensureHttpsDir();
+  const configPath = path.join(HTTPS_DIR, 'openssl.cnf');
+  fs.writeFileSync(configPath, buildOpenSslConfig(), 'utf8');
+
+  execFileSync(command, [
+    'req',
+    '-x509',
+    '-nodes',
+    '-newkey',
+    'rsa:2048',
+    '-sha256',
+    '-days',
+    '825',
+    '-keyout',
+    HTTPS_KEY_FILE,
+    '-out',
+    HTTPS_CERT_FILE,
+    '-config',
+    configPath
+  ], {
+    stdio: 'ignore'
+  });
+
+  writeMeta({
+    generator: 'openssl',
+    createdAt: new Date().toISOString()
+  });
+}
+
+function buildWindowsPfxGenerationScript(outputPath, passphrase) {
+  return [
+    '$ErrorActionPreference = "Stop"',
+    '$rsa = [System.Security.Cryptography.RSA]::Create(2048)',
+    '$req = [System.Security.Cryptography.X509Certificates.CertificateRequest]::new(',
+    '  "CN=localhost",',
+    '  $rsa,',
+    '  [System.Security.Cryptography.HashAlgorithmName]::SHA256,',
+    '  [System.Security.Cryptography.RSASignaturePadding]::Pkcs1',
+    ')',
+    '$san = [System.Security.Cryptography.X509Certificates.SubjectAlternativeNameBuilder]::new()',
+    '$san.AddDnsName("localhost")',
+    '$san.AddIpAddress([System.Net.IPAddress]::Parse("127.0.0.1"))',
+    '$req.CertificateExtensions.Add($san.Build($false))',
+    '$req.CertificateExtensions.Add([System.Security.Cryptography.X509Certificates.X509BasicConstraintsExtension]::new($false, $false, 0, $true))',
+    '$req.CertificateExtensions.Add([System.Security.Cryptography.X509Certificates.X509KeyUsageExtension]::new([System.Security.Cryptography.X509Certificates.X509KeyUsageFlags]::DigitalSignature -bor [System.Security.Cryptography.X509Certificates.X509KeyUsageFlags]::KeyEncipherment, $true))',
+    '$req.CertificateExtensions.Add([System.Security.Cryptography.X509Certificates.X509SubjectKeyIdentifierExtension]::new($req.PublicKey, $false))',
+    '$notBefore = [DateTimeOffset]::UtcNow.AddDays(-1)',
+    '$notAfter = $notBefore.AddYears(2)',
+    '$cert = $req.CreateSelfSigned($notBefore, $notAfter)',
+    `$bytes = $cert.Export([System.Security.Cryptography.X509Certificates.X509ContentType]::Pfx, ${JSON.stringify(passphrase)})`,
+    `[System.IO.Directory]::CreateDirectory(${JSON.stringify(HTTPS_DIR)}) | Out-Null`,
+    `[System.IO.File]::WriteAllBytes(${JSON.stringify(outputPath)}, $bytes)`,
+    '$cert.Dispose()',
+    '$rsa.Dispose()'
+  ].join('; ');
+}
+
+function generatePfxCertificateOnWindows() {
+  ensureHttpsDir();
+  const passphrase = randomBytes(18).toString('base64url');
+
+  execFileSync('powershell', [
+    '-NoProfile',
+    '-Command',
+    buildWindowsPfxGenerationScript(HTTPS_PFX_FILE, passphrase)
+  ], {
+    stdio: 'ignore',
+    windowsHide: true
+  });
+
+  writeMeta({
+    generator: 'powershell-pfx',
+    passphrase,
+    createdAt: new Date().toISOString()
+  });
+}
+
+function ensureHttpsCredentials() {
+  ensureHttpsDir();
+
+  if (fs.existsSync(HTTPS_KEY_FILE) && fs.existsSync(HTTPS_CERT_FILE)) {
+    return {
+      key: fs.readFileSync(HTTPS_KEY_FILE),
+      cert: fs.readFileSync(HTTPS_CERT_FILE)
+    };
+  }
+
+  const meta = readMeta();
+  if (fs.existsSync(HTTPS_PFX_FILE) && meta.passphrase) {
+    return {
+      pfx: fs.readFileSync(HTTPS_PFX_FILE),
+      passphrase: meta.passphrase
+    };
+  }
+
+  const openSslCommand = resolveOpenSslCommand();
+  if (openSslCommand) {
+    generatePemCertificateWithOpenSsl(openSslCommand);
+    return {
+      key: fs.readFileSync(HTTPS_KEY_FILE),
+      cert: fs.readFileSync(HTTPS_CERT_FILE)
+    };
+  }
+
+  if (process.platform === 'win32') {
+    generatePfxCertificateOnWindows();
+    const nextMeta = readMeta();
+    return {
+      pfx: fs.readFileSync(HTTPS_PFX_FILE),
+      passphrase: nextMeta.passphrase
+    };
+  }
+
+  throw new Error('无法生成 HTTPS 本地证书，请先安装 openssl 后重试');
+}
+
+module.exports = {
+  ensureHttpsCredentials,
+  _test: {
+    buildOpenSslConfig,
+    buildWindowsPfxGenerationScript,
+    resolveOpenSslCommand
+  }
+};

package/src/server/services/notification-hooks.js

@@ -13,7 +13,7 @@ const MANAGED_HOOK_NAME = 'coding-tool-notify';
 const MANAGED_OPENCODE_PLUGIN_FILE = 'coding-tool-notify.js';
 
 function normalizeType(type) {
-  return type === 'dialog' ? 'dialog' : 'notification';
+  return type === 'dialog' || type === 'browser' ? type : 'notification';
 }
 
 function ensureParentDir(filePath) {
@@ -118,9 +118,9 @@ function removeNotifyScript() {
 function parseManagedType(input) {
   const value = String(input || '');
   const matches = [
-    value.match(/--cc-notify-type=(dialog|notification)/i),
-    value.match(/--mode=(dialog|notification)/i),
-    value.match(/MODE\s*=\s*["'](dialog|notification)["']/i)
+    value.match(/--cc-notify-type=(dialog|notification|browser)/i),
+    value.match(/--mode=(dialog|notification|browser)/i),
+    value.match(/MODE\s*=\s*["'](dialog|notification|browser)["']/i)
   ];
 
   for (const match of matches) {
@@ -446,6 +446,7 @@ const { execSync, execFileSync } = require('child_process')
 
 const FEISHU_ENABLED = ${feishuEnabled ? 'true' : 'false'}
 const FEISHU_WEBHOOK_URL = ${JSON.stringify(feishuEnabled ? feishu.webhookUrl : '')}
+const CONFIG_FILE = ${JSON.stringify(PATHS.configFile)}
 
 function readArg(name) {
   const prefix = \`\${name}=\`
@@ -507,10 +508,77 @@ function resolveMessage(source, eventType, payload) {
   return 'Claude Code 任务已完成 | 等待交互'
 }
 
+function readWebUiPort() {
+  try {
+    const config = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'))
+    const port = parseInt(config?.ports?.webUI, 10)
+    return Number.isFinite(port) ? port : 19999
+  } catch (error) {
+    return 19999
+  }
+}
+
+function postBrowserNotification(source, eventType, message) {
+  const payload = JSON.stringify({
+    source,
+    eventType,
+    message
+  })
+  const port = readWebUiPort()
+  const attempts = [
+    { module: https, options: { rejectUnauthorized: false } },
+    { module: http, options: {} }
+  ]
+
+  return new Promise((resolve) => {
+    const runAttempt = (index) => {
+      const current = attempts[index]
+      if (!current) {
+        resolve()
+        return
+      }
+
+      const request = current.module.request({
+        hostname: '127.0.0.1',
+        port,
+        path: '/api/hooks/browser-event',
+        method: 'POST',
+        timeout: 1500,
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(payload)
+        },
+        ...current.options
+      }, (response) => {
+        response.resume()
+        if (response.statusCode >= 200 && response.statusCode < 300) {
+          resolve()
+          return
+        }
+        runAttempt(index + 1)
+      })
+
+      request.on('error', () => runAttempt(index + 1))
+      request.on('timeout', () => {
+        request.destroy()
+        runAttempt(index + 1)
+      })
+      request.write(payload)
+      request.end()
+    }
+
+    runAttempt(0)
+  })
+}
+
 function notify(mode, message) {
   const title = 'Coding Tool'
   const platform = os.platform()
 
+  if (mode === 'browser') {
+    return
+  }
+
   try {
     if (platform === 'darwin') {
       if (mode === 'dialog') {
@@ -635,7 +703,11 @@ function sendFeishu(message, source) {
   const payload = readOptionalPayload()
   const message = resolveMessage(source, eventType, payload)
 
-  notify(mode === 'dialog' ? 'dialog' : 'notification', message)
+  if (mode === 'browser') {
+    await postBrowserNotification(source, eventType, message)
+  } else {
+    notify(mode, message)
+  }
   await sendFeishu(message, source)
 })().catch(() => {
   process.exit(0)
@@ -1183,6 +1255,55 @@ function normalizePlatformInput(platform = {}) {
   };
 }
 
+function resolveBrowserNotificationTitle(source = 'claude') {
+  switch (String(source || '').toLowerCase()) {
+    case 'codex':
+      return 'Codex CLI';
+    case 'gemini':
+      return 'Gemini CLI';
+    case 'opencode':
+      return 'OpenCode';
+    default:
+      return 'Claude Code';
+  }
+}
+
+function resolveBrowserNotificationUrl(source = 'claude') {
+  switch (String(source || '').toLowerCase()) {
+    case 'codex':
+      return '/codex';
+    case 'gemini':
+      return '/gemini';
+    case 'opencode':
+      return '/opencode';
+    default:
+      return '/claude';
+  }
+}
+
+function emitBrowserNotification(input = {}) {
+  const source = String(input.source || 'claude').toLowerCase();
+  const message = String(input.message || '').trim();
+  if (!message) {
+    throw createValidationError('缺少浏览器通知内容');
+  }
+
+  const payload = {
+    type: 'browser-notification',
+    id: input.id || `${source}-${Date.now()}`,
+    source,
+    eventType: String(input.eventType || '').trim(),
+    title: String(input.title || resolveBrowserNotificationTitle(source)).trim(),
+    message,
+    url: String(input.url || resolveBrowserNotificationUrl(source)).trim(),
+    timestamp: Date.now()
+  };
+
+  const { broadcastBrowserNotification } = require('../websocket-server');
+  broadcastBrowserNotification(payload);
+  return payload;
+}
+
 function saveNotificationSettings(input = {}) {
   const existingFeishu = getFeishuConfig();
   const requestedWebhookUrl = String(input?.feishu?.webhookUrl || '').trim();
@@ -1220,7 +1341,7 @@ function saveNotificationSettings(input = {}) {
 }
 
 function parseNotifyTypeMarker(command) {
-  const marker = String(command || '').match(/--cc-notify-type=(['"])?(dialog|notification)\1/i);
+  const marker = String(command || '').match(/--cc-notify-type=(['"])?(dialog|notification|browser)\1/i);
   return marker?.[2] ? normalizeType(marker[2].toLowerCase()) : null;
 }
 
@@ -1566,6 +1687,15 @@ function testNotification({ type, testFeishu, webhookUrl } = {}) {
     return sendFeishuTest(webhookUrl);
   }
 
+  if (normalizeType(type) === 'browser') {
+    emitBrowserNotification({
+      source: 'claude',
+      title: 'coding-tool-x',
+      message: '这是一条浏览器测试通知'
+    });
+    return;
+  }
+
   runSystemNotification(type || 'notification', '这是一条测试通知');
 }
 
@@ -1576,6 +1706,7 @@ module.exports = {
   saveNotificationSettings,
   saveLegacyClaudeHookSettings,
   testNotification,
+  emitBrowserNotification,
   initDefaultHooks,
   syncManagedNotificationAssets,
   getOpenCodeManagedPluginPath,
@@ -1604,6 +1735,7 @@ module.exports = {
     getOpenCodeManagedPluginPath,
     generateNotifyScript,
     generateSystemNotificationCommand,
+    emitBrowserNotification,
     parseStopHookStatus,
     shouldRepairStopHook
   }

package/src/server/services/opencode-gateway-converter.js

@@ -11,6 +11,8 @@
  * - OpenAI Chat Completions API (/v1/chat/completions)
  */
 
+const { ensureOpenAiStreamUsage } = require('./base/proxy-utils');
+
 const SUPPORTED_SOURCE_TYPES = ['claude', 'codex', 'gemini'];
 const SUPPORTED_TARGET_APIS = ['responses', 'chat.completions'];
 
@@ -554,6 +556,7 @@ function buildChatCompletionsRequest(normalized, options, warnings) {
     if (chatTools.length > 0) request.tools = chatTools;
   }
 
+  ensureOpenAiStreamUsage(request);
   return request;
 }
 

package/src/server/services/opencode-statistics-service.js

@@ -110,6 +110,7 @@ function recordRequest(requestData = {}) {
       input: normalizedTokens.input,
       output: normalizedTokens.output,
       reasoning: normalizedTokens.reasoning,
+      cached: normalizedTokens.cached,
       cacheCreation: normalizedTokens.cacheCreation,
       cacheRead: normalizedTokens.cacheRead,
       total: normalizedTokens.total