@chenpu17/cc-gw 0.5.0 → 0.5.2

package/src/server/dist/index.js

@@ -9921,6 +9921,7 @@ var LOG_LEVELS = /* @__PURE__ */ new Set([
 var HOME_OVERRIDE = process.env.CC_GW_HOME;
 var HOME_DIR = path.resolve(HOME_OVERRIDE ?? path.join(os.homedir(), ".cc-gw"));
 var CONFIG_PATH = path.join(HOME_DIR, "config.json");
+var CERTS_DIR = path.join(HOME_DIR, "certs");
 var TypedEmitter = class extends EventEmitter {
   on(event, listener) {
     return super.on(event, listener);
@@ -9973,6 +9974,42 @@ function sanitizeModelRoutes(input) {
   }
   return sanitized;
 }
+function migrateProtocolConfig(data) {
+  if (data.http || data.https) {
+    return;
+  }
+  const port = typeof data.port === "number" ? data.port : 4100;
+  const host = typeof data.host === "string" ? data.host : "127.0.0.1";
+  data.http = {
+    enabled: true,
+    port,
+    host
+  };
+  const hasLegacyHttpsConfig = typeof data.httpsPort === "number" || typeof data.keyPath === "string" && data.keyPath || typeof data.certPath === "string" && data.certPath;
+  data.https = {
+    enabled: hasLegacyHttpsConfig ? true : false,
+    port: typeof data.httpsPort === "number" ? data.httpsPort : 4443,
+    host: typeof data.httpsHost === "string" ? data.httpsHost : host,
+    keyPath: typeof data.keyPath === "string" ? data.keyPath : path.join(CERTS_DIR, "key.pem"),
+    certPath: typeof data.certPath === "string" ? data.certPath : path.join(CERTS_DIR, "cert.pem"),
+    caPath: typeof data.caPath === "string" ? data.caPath : ""
+  };
+  data.port = port;
+  data.host = host;
+}
+function validateProtocolConfig(data) {
+  const httpEnabled = data.http?.enabled === true;
+  const httpsEnabled = data.https?.enabled === true;
+  if (!httpEnabled && !httpsEnabled) {
+    throw new Error("\u81F3\u5C11\u9700\u8981\u542F\u7528 HTTP \u6216 HTTPS \u534F\u8BAE");
+  }
+  if (httpsEnabled) {
+    const https = data.https;
+    if (!https.keyPath || !https.certPath) {
+      throw new Error("HTTPS \u5DF2\u542F\u7528\u4F46\u7F3A\u5C11\u8BC1\u4E66\u8DEF\u5F84\u914D\u7F6E");
+    }
+  }
+}
 function sanitizeWebAuth(input) {
   if (!input || typeof input !== "object") {
     return {
@@ -10021,8 +10058,10 @@ function resolveEndpointRouting(source, fallback) {
 }
 function parseConfig(raw) {
   const data = JSON.parse(raw);
+  migrateProtocolConfig(data);
+  validateProtocolConfig(data);
   if (typeof data.port !== "number") {
-    throw new Error("\u914D\u7F6E\u6587\u4EF6\u7F3A\u5C11\u6216\u9519\u8BEF\u7684 port \u5B57\u6BB5");
+    data.port = data.http?.port ?? 4100;
   }
   if (!Array.isArray(data.providers)) {
     data.providers = [];
@@ -12132,8 +12171,8 @@ async function registerMessagesRoute(app) {
     if (providerType === "anthropic") {
       providerBody = cloneOriginalPayload(payload);
       providerBody.model = target.modelId;
-      if (normalized.stream !== void 0) {
-        providerBody.stream = normalized.stream;
+      if (Object.prototype.hasOwnProperty.call(payload, "stream")) {
+        providerBody.stream = Boolean(payload.stream);
       }
       const collected = {};
       const skip = /* @__PURE__ */ new Set(["content-length", "host", "connection", "transfer-encoding"]);
@@ -12253,8 +12292,8 @@ async function registerMessagesRoute(app) {
         if (providerType === "anthropic") {
           let inputTokens2 = json.usage?.input_tokens ?? 0;
           let outputTokens2 = json.usage?.output_tokens ?? 0;
-          const cached2 = resolveCachedTokens(json.usage);
-          const cachedTokens2 = cached2.read + cached2.creation;
+          const cached3 = resolveCachedTokens(json.usage);
+          const cachedTokens3 = cached3.read + cached3.creation;
           if (!inputTokens2) {
             inputTokens2 = target.tokenEstimate || estimateTokens(normalized, target.modelId);
           }
@@ -12265,13 +12304,15 @@ async function registerMessagesRoute(app) {
           logUsage("non_stream.anthropic", {
             input: inputTokens2,
             output: outputTokens2,
-            cached: cachedTokens2
+            cached: cachedTokens3
           });
           const latencyMs2 = Date.now() - requestStart;
           await updateLogTokens(logId, {
             inputTokens: inputTokens2,
             outputTokens: outputTokens2,
-            cachedTokens: cachedTokens2,
+            cachedTokens: cachedTokens3,
+            cacheReadTokens: cached3.read,
+            cacheCreationTokens: cached3.creation,
             ttftMs: latencyMs2,
             tpotMs: computeTpot(latencyMs2, outputTokens2, { streaming: false })
           });
@@ -12280,9 +12321,9 @@ async function registerMessagesRoute(app) {
             requests: 1,
             inputTokens: inputTokens2,
             outputTokens: outputTokens2,
-            cachedTokens: cachedTokens2,
-            cacheReadTokens: cached2.read,
-            cacheCreationTokens: cached2.creation,
+            cachedTokens: cachedTokens3,
+            cacheReadTokens: cached3.read,
+            cacheCreationTokens: cached3.creation,
             latencyMs: latencyMs2
           });
           if (storeResponsePayloads) {
@@ -12303,8 +12344,8 @@ async function registerMessagesRoute(app) {
         const claudeResponse = buildClaudeResponse(json, target.modelId);
         let inputTokens = json.usage?.prompt_tokens ?? 0;
         let outputTokens = json.usage?.completion_tokens ?? 0;
-        const cached = resolveCachedTokens(json.usage);
-        const cachedTokens = cached.read + cached.creation;
+        const cached2 = resolveCachedTokens(json.usage);
+        const cachedTokens2 = cached2.read + cached2.creation;
         if (!inputTokens) {
           inputTokens = target.tokenEstimate || estimateTokens(normalized, target.modelId);
         }
@@ -12315,13 +12356,15 @@ async function registerMessagesRoute(app) {
         logUsage("non_stream.openai", {
           input: inputTokens,
           output: outputTokens,
-          cached: cachedTokens
+          cached: cachedTokens2
         });
         const latencyMs = Date.now() - requestStart;
         await updateLogTokens(logId, {
           inputTokens,
           outputTokens,
-          cachedTokens,
+          cachedTokens: cachedTokens2,
+          cacheReadTokens: cached2.read,
+          cacheCreationTokens: cached2.creation,
           ttftMs: latencyMs,
           tpotMs: computeTpot(latencyMs, outputTokens, { streaming: false })
         });
@@ -12330,9 +12373,9 @@ async function registerMessagesRoute(app) {
           requests: 1,
           inputTokens,
           outputTokens,
-          cachedTokens,
-          cacheReadTokens: cached.read,
-          cacheCreationTokens: cached.creation,
+          cachedTokens: cachedTokens2,
+          cacheReadTokens: cached2.read,
+          cacheCreationTokens: cached2.creation,
           latencyMs
         });
         if (storeResponsePayloads) {
@@ -12369,6 +12412,8 @@ async function registerMessagesRoute(app) {
         let usagePrompt2 = 0;
         let usageCompletion2 = 0;
         let usageCached2 = null;
+        let usageCacheRead2 = 0;
+        let usageCacheCreation2 = 0;
         let accumulatedContent2 = "";
         let firstTokenAt2 = null;
         let lastUsagePayload = null;
@@ -12504,6 +12549,8 @@ async function registerMessagesRoute(app) {
                         usagePrompt2 = payload2.usage.input_tokens ?? usagePrompt2;
                         usageCompletion2 = payload2.usage.output_tokens ?? usageCompletion2;
                         const maybeCached = resolveCachedTokens(payload2.usage);
+                        usageCacheRead2 = maybeCached.read;
+                        usageCacheCreation2 = maybeCached.creation;
                         usageCached2 = maybeCached.read + maybeCached.creation;
                         lastUsagePayload = payload2.usage;
                       }
@@ -12531,6 +12578,8 @@ async function registerMessagesRoute(app) {
                         usagePrompt2 = payload2.usage.input_tokens ?? usagePrompt2;
                         usageCompletion2 = payload2.usage.output_tokens ?? usageCompletion2;
                         const maybeCached = resolveCachedTokens(payload2.usage);
+                        usageCacheRead2 = maybeCached.read;
+                        usageCacheCreation2 = maybeCached.creation;
                         usageCached2 = maybeCached.read + maybeCached.creation;
                         lastUsagePayload = payload2.usage;
                       }
@@ -12583,9 +12632,11 @@ async function registerMessagesRoute(app) {
         }
         const totalLatencyMs = Date.now() - requestStart;
         const ttftMs = firstTokenAt2 ? firstTokenAt2 - requestStart : null;
-        const cached = resolveCachedTokens(lastUsagePayload);
         if (usageCached2 === null) {
-          usageCached2 = cached.read + cached.creation;
+          const cached2 = resolveCachedTokens(lastUsagePayload);
+          usageCacheRead2 = cached2.read;
+          usageCacheCreation2 = cached2.creation;
+          usageCached2 = cached2.read + cached2.creation;
         }
         logUsage("stream.anthropic.final", {
           input: usagePrompt2,
@@ -12596,8 +12647,8 @@ async function registerMessagesRoute(app) {
           inputTokens: usagePrompt2,
           outputTokens: usageCompletion2,
           cachedTokens: usageCached2,
-          cacheReadTokens: cached.read,
-          cacheCreationTokens: cached.creation,
+          cacheReadTokens: usageCacheRead2,
+          cacheCreationTokens: usageCacheCreation2,
           ttftMs,
           tpotMs: computeTpot(totalLatencyMs, usageCompletion2, {
             streaming: true,
@@ -12610,8 +12661,8 @@ async function registerMessagesRoute(app) {
           inputTokens: usagePrompt2,
           outputTokens: usageCompletion2,
           cachedTokens: usageCached2,
-          cacheReadTokens: cached.read,
-          cacheCreationTokens: cached.creation,
+          cacheReadTokens: usageCacheRead2,
+          cacheCreationTokens: usageCacheCreation2,
           latencyMs: totalLatencyMs
         });
         if (storeResponsePayloads) {
@@ -12688,6 +12739,8 @@ async function registerMessagesRoute(app) {
       let usagePrompt = 0;
       let usageCompletion = 0;
       let usageCached = null;
+      let usageCacheRead = 0;
+      let usageCacheCreation = 0;
       let accumulatedContent = "";
       let completed = false;
       let firstTokenAt = null;
@@ -12828,9 +12881,10 @@ data: ${JSON.stringify(data)}
           if (usagePayload) {
             usagePrompt = usagePayload.prompt_tokens ?? usagePrompt;
             usageCompletion = usagePayload.completion_tokens ?? usageCompletion;
-            if (typeof usagePayload.cached_tokens === "number") {
-              usageCached = usagePayload.cached_tokens;
-            }
+            const maybeCached = resolveCachedTokens(usagePayload);
+            usageCacheRead = maybeCached.read;
+            usageCacheCreation = maybeCached.creation;
+            usageCached = maybeCached.read + maybeCached.creation;
           }
           if (choice.delta?.tool_calls) {
             request.log.debug({ event: "debug.tool_call_delta", delta: choice.delta?.tool_calls }, "tool call delta received");
@@ -12937,8 +12991,8 @@ data: ${JSON.stringify(data)}
           inputTokens: fallbackPrompt,
           outputTokens: fallbackCompletion,
           cachedTokens: usageCached,
-          cacheReadTokens: 0,
-          cacheCreationTokens: 0,
+          cacheReadTokens: usageCacheRead,
+          cacheCreationTokens: usageCacheCreation,
           ttftMs,
           tpotMs: computeTpot(totalLatencyMs, fallbackCompletion, {
             streaming: true,
@@ -12951,8 +13005,8 @@ data: ${JSON.stringify(data)}
           inputTokens: fallbackPrompt,
           outputTokens: fallbackCompletion,
           cachedTokens: usageCached ?? 0,
-          cacheReadTokens: 0,
-          cacheCreationTokens: 0,
+          cacheReadTokens: usageCacheRead,
+          cacheCreationTokens: usageCacheCreation,
           latencyMs: totalLatencyMs
         });
         if (storeResponsePayloads) {
@@ -13791,7 +13845,9 @@ async function registerOpenAiRoutes(app) {
           overrideTools: Array.isArray(payload.tools) ? payload.tools : void 0
         });
         providerBody.model = target.modelId;
-        providerBody.stream = normalized.stream;
+        if (Object.prototype.hasOwnProperty.call(payload, "stream")) {
+          providerBody.stream = Boolean(payload.stream);
+        }
         const rawHeaders = request.raw?.headers ?? request.headers;
         const forwarded = collectAnthropicForwardHeaders(rawHeaders);
         providerHeaders = filterForwardedAnthropicHeaders(forwarded);
@@ -13830,7 +13886,9 @@ async function registerOpenAiRoutes(app) {
       } else {
         providerBody = { ...payload };
         providerBody.model = target.modelId;
-        providerBody.stream = normalized.stream;
+        if (Object.prototype.hasOwnProperty.call(payload, "stream")) {
+          providerBody.stream = Boolean(payload.stream);
+        }
         if (providerBody.max_output_tokens == null && typeof providerBody.max_tokens === "number") {
           providerBody.max_output_tokens = providerBody.max_tokens;
         }
@@ -13896,20 +13954,20 @@ async function registerOpenAiRoutes(app) {
           if (!Number.isFinite(inputTokens3) || inputTokens3 <= 0) {
             inputTokens3 = target.tokenEstimate ?? estimateTokens(normalized, target.modelId);
           }
-          const cached2 = resolveCachedTokens2(usagePayload2);
-          const cachedTokens2 = cached2.read + cached2.creation;
+          const cached3 = resolveCachedTokens2(usagePayload2);
+          const cachedTokens3 = cached3.read + cached3.creation;
           const latencyMs3 = Date.now() - requestStart;
           const openAIResponse = buildOpenAIResponseFromClaude(parsed, target.modelId, converted, {
             inputTokens: inputTokens3,
             outputTokens: outputTokens3,
-            cachedTokens: cachedTokens2
+            cachedTokens: cachedTokens3
           });
           await updateLogTokens(logId, {
             inputTokens: inputTokens3,
             outputTokens: outputTokens3,
-            cachedTokens: usageCached,
-            cacheReadTokens: cached2.read,
-            cacheCreationTokens: cached2.creation,
+            cachedTokens: cachedTokens3,
+            cacheReadTokens: cached3.read,
+            cacheCreationTokens: cached3.creation,
             ttftMs: latencyMs3,
             tpotMs: computeTpot2(latencyMs3, outputTokens3, { streaming: false })
           });
@@ -13918,9 +13976,9 @@ async function registerOpenAiRoutes(app) {
             requests: 1,
             inputTokens: inputTokens3,
             outputTokens: outputTokens3,
-            cachedTokens: usageCached,
-            cacheReadTokens: usageCacheRead,
-            cacheCreationTokens: usageCacheCreation,
+            cachedTokens: cachedTokens3,
+            cacheReadTokens: cached3.read,
+            cacheCreationTokens: cached3.creation,
             latencyMs: latencyMs3
           });
           if (storeResponsePayloads) {
@@ -13955,15 +14013,15 @@ async function registerOpenAiRoutes(app) {
           return 0;
         })();
         const outputTokens2 = baseOutputTokens + reasoningTokens2;
-        const cached = resolveCachedTokens2(usagePayload);
-        const cachedTokens = cached.read + cached.creation;
+        const cached2 = resolveCachedTokens2(usagePayload);
+        const cachedTokens2 = cached2.read + cached2.creation;
         const latencyMs2 = Date.now() - requestStart;
         await updateLogTokens(logId, {
           inputTokens: inputTokens2,
           outputTokens: outputTokens2,
-          cachedTokens: usageCached,
-          cacheReadTokens: cached.read,
-          cacheCreationTokens: cached.creation,
+          cachedTokens: cachedTokens2,
+          cacheReadTokens: cached2.read,
+          cacheCreationTokens: cached2.creation,
           ttftMs: usagePayload?.first_token_latency_ms ?? latencyMs2,
           tpotMs: usagePayload?.tokens_per_second ? computeTpot2(latencyMs2, outputTokens2, { streaming: false, reasoningTokens: reasoningTokens2 }) : null
         });
@@ -13972,6 +14030,9 @@ async function registerOpenAiRoutes(app) {
           requests: 1,
           inputTokens: inputTokens2,
           outputTokens: outputTokens2,
+          cachedTokens: cachedTokens2,
+          cacheReadTokens: cached2.read,
+          cacheCreationTokens: cached2.creation,
           latencyMs: latencyMs2
         });
         await finalize(200, null);
@@ -14353,8 +14414,8 @@ async function registerOpenAiRoutes(app) {
           inputTokens: finalPromptTokens,
           outputTokens: finalCompletionTokens,
           cachedTokens: finalCachedTokens ?? null,
-          cacheReadTokens: 0,
-          cacheCreationTokens: 0,
+          cacheReadTokens: finalCachedResult.read,
+          cacheCreationTokens: finalCachedResult.creation,
           ttftMs,
           tpotMs: computeTpot2(totalLatencyMs, finalCompletionTokens, {
             streaming: true,
@@ -14520,12 +14581,16 @@ async function registerOpenAiRoutes(app) {
       const textOutputTokens = usageCompletion ?? 0;
       const reasoningTokens = usageReasoning ?? 0;
       const outputTokens = textOutputTokens + reasoningTokens;
+      const hasCacheStats = usageCached != null;
+      const resolvedCachedTokens = hasCacheStats ? usageCached : null;
+      const resolvedCacheRead = hasCacheStats ? usageCacheRead : null;
+      const resolvedCacheCreation = hasCacheStats ? usageCacheCreation : null;
       await updateLogTokens(logId, {
         inputTokens,
         outputTokens,
-        cachedTokens: usageCached,
-        cacheReadTokens: 0,
-        cacheCreationTokens: 0,
+        cachedTokens: resolvedCachedTokens,
+        cacheReadTokens: resolvedCacheRead,
+        cacheCreationTokens: resolvedCacheCreation,
         ttftMs: firstTokenAt ? firstTokenAt - requestStart : null,
         tpotMs: computeTpot2(latencyMs, outputTokens, {
           streaming: true,
@@ -14538,6 +14603,9 @@ async function registerOpenAiRoutes(app) {
         requests: 1,
         inputTokens,
         outputTokens,
+        cachedTokens: resolvedCachedTokens ?? 0,
+        cacheReadTokens: resolvedCacheRead ?? 0,
+        cacheCreationTokens: resolvedCacheCreation ?? 0,
         latencyMs
       });
       await finalize(200, null);
@@ -14669,7 +14737,9 @@ async function registerOpenAiRoutes(app) {
           overrideTools
         });
         providerBody.model = target.modelId;
-        providerBody.stream = normalized.stream;
+        if (Object.prototype.hasOwnProperty.call(payload, "stream")) {
+          providerBody.stream = Boolean(payload.stream);
+        }
         const rawHeaders = request.raw?.headers ?? request.headers;
         const forwarded = collectAnthropicForwardHeaders(rawHeaders);
         providerHeaders = filterForwardedAnthropicHeaders(forwarded);
@@ -14713,7 +14783,9 @@ async function registerOpenAiRoutes(app) {
           overrideTools
         });
         providerBody.model = target.modelId;
-        providerBody.stream = normalized.stream;
+        if (Object.prototype.hasOwnProperty.call(payload, "stream")) {
+          providerBody.stream = Boolean(payload.stream);
+        }
         if (Array.isArray(payload.functions) && !providerBody.functions) {
           providerBody.functions = payload.functions;
         }
@@ -14783,15 +14855,15 @@ async function registerOpenAiRoutes(app) {
             inputTokens: inputTokens3,
             outputTokens: outputTokens3
           });
-          const cached2 = resolveCachedTokens2(usagePayload2);
-          const cachedTokens2 = cached2.read + cached2.creation;
+          const cached3 = resolveCachedTokens2(usagePayload2);
+          const cachedTokens3 = cached3.read + cached3.creation;
           const latencyMs3 = Date.now() - requestStart;
           await updateLogTokens(logId, {
             inputTokens: inputTokens3,
             outputTokens: outputTokens3,
-            cachedTokens: usageCached,
-            cacheReadTokens: cached2.read,
-            cacheCreationTokens: cached2.creation,
+            cachedTokens: cachedTokens3,
+            cacheReadTokens: cached3.read,
+            cacheCreationTokens: cached3.creation,
             ttftMs: latencyMs3,
             tpotMs: computeTpot2(latencyMs3, outputTokens3, { streaming: false })
           });
@@ -14800,9 +14872,9 @@ async function registerOpenAiRoutes(app) {
             requests: 1,
             inputTokens: inputTokens3,
             outputTokens: outputTokens3,
-            cachedTokens: usageCached,
-            cacheReadTokens: usageCacheRead,
-            cacheCreationTokens: usageCacheCreation,
+            cachedTokens: cachedTokens3,
+            cacheReadTokens: cached3.read,
+            cacheCreationTokens: cached3.creation,
             latencyMs: latencyMs3
           });
           if (storeResponsePayloads) {
@@ -14832,15 +14904,15 @@ async function registerOpenAiRoutes(app) {
           })(),
           target.modelId
         );
-        const cached = resolveCachedTokens2(usagePayload);
-        const cachedTokens = cached.read + cached.creation;
+        const cached2 = resolveCachedTokens2(usagePayload);
+        const cachedTokens2 = cached2.read + cached2.creation;
         const latencyMs2 = Date.now() - requestStart;
         await updateLogTokens(logId, {
           inputTokens: inputTokens2,
           outputTokens: outputTokens2,
-          cachedTokens: usageCached,
-          cacheReadTokens: cached.read,
-          cacheCreationTokens: cached.creation,
+          cachedTokens: cachedTokens2,
+          cacheReadTokens: cached2.read,
+          cacheCreationTokens: cached2.creation,
           ttftMs: usagePayload?.first_token_latency_ms ?? latencyMs2,
           tpotMs: usagePayload?.tokens_per_second ? computeTpot2(latencyMs2, outputTokens2, { streaming: false }) : null
         });
@@ -14849,6 +14921,9 @@ async function registerOpenAiRoutes(app) {
           requests: 1,
           inputTokens: inputTokens2,
           outputTokens: outputTokens2,
+          cachedTokens: cachedTokens2,
+          cacheReadTokens: cached2.read,
+          cacheCreationTokens: cached2.creation,
           latencyMs: latencyMs2
         });
         await finalize(200, null);
@@ -15273,8 +15348,8 @@ async function registerOpenAiRoutes(app) {
           inputTokens: finalPromptTokens,
           outputTokens: finalCompletionTokens,
           cachedTokens: finalCachedTokens ?? null,
-          cacheReadTokens: 0,
-          cacheCreationTokens: 0,
+          cacheReadTokens: finalCachedResult.read,
+          cacheCreationTokens: finalCachedResult.creation,
           ttftMs,
           tpotMs: computeTpot2(totalLatencyMs, finalCompletionTokens, {
             streaming: true,
@@ -15415,12 +15490,16 @@ async function registerOpenAiRoutes(app) {
       const latencyMs = Date.now() - requestStart;
       const inputTokens = usagePrompt ?? usageCompletion ?? target.tokenEstimate ?? estimateTokens(normalized, target.modelId);
       const outputTokens = usageCompletion ?? 0;
+      const hasCacheStats = usageCached != null;
+      const resolvedCachedTokens = hasCacheStats ? usageCached : null;
+      const resolvedCacheRead = hasCacheStats ? usageCacheRead : null;
+      const resolvedCacheCreation = hasCacheStats ? usageCacheCreation : null;
       await updateLogTokens(logId, {
         inputTokens,
         outputTokens,
-        cachedTokens: usageCached,
-        cacheReadTokens: 0,
-        cacheCreationTokens: 0,
+        cachedTokens: resolvedCachedTokens,
+        cacheReadTokens: resolvedCacheRead,
+        cacheCreationTokens: resolvedCacheCreation,
         ttftMs: firstTokenAt ? firstTokenAt - requestStart : null,
         tpotMs: computeTpot2(latencyMs, outputTokens, {
           streaming: true,
@@ -15432,6 +15511,9 @@ async function registerOpenAiRoutes(app) {
         requests: 1,
         inputTokens,
         outputTokens,
+        cachedTokens: resolvedCachedTokens ?? 0,
+        cacheReadTokens: resolvedCacheRead ?? 0,
+        cacheCreationTokens: resolvedCacheCreation ?? 0,
         latencyMs
       });
       await finalize(200, null);
@@ -15597,7 +15679,7 @@ async function queryLogs(options = {}) {
   const items = await getAll(
     `SELECT id, timestamp, session_id, endpoint, provider, model, client_model,
             stream, latency_ms, status_code, input_tokens, output_tokens,
-            cached_tokens, ttft_ms, tpot_ms, error, api_key_id, api_key_name, api_key_value
+            cached_tokens, cache_read_tokens, cache_creation_tokens, ttft_ms, tpot_ms, error, api_key_id, api_key_name, api_key_value
        FROM request_logs
        ${whereClause}
        ORDER BY timestamp DESC
@@ -15613,7 +15695,7 @@ async function getLogDetail(id) {
   const record = await getOne(
     `SELECT id, timestamp, session_id, endpoint, provider, model, client_model,
             stream, latency_ms, status_code, input_tokens, output_tokens,
-            cached_tokens, ttft_ms, tpot_ms, error, api_key_id, api_key_name, api_key_value
+            cached_tokens, cache_read_tokens, cache_creation_tokens, ttft_ms, tpot_ms, error, api_key_id, api_key_name, api_key_value
        FROM request_logs
        WHERE id = ?`,
     [id]
@@ -15663,6 +15745,8 @@ async function exportLogs(options = {}) {
             l.input_tokens,
             l.output_tokens,
             l.cached_tokens,
+            l.cache_read_tokens,
+            l.cache_creation_tokens,
             l.ttft_ms,
             l.tpot_ms,
             l.error,
@@ -17521,8 +17605,8 @@ async function handleAnthropicProtocol(request, reply, endpoint, endpointId, app
     if (providerType === "anthropic") {
       providerBody = cloneOriginalPayload2(payload);
       providerBody.model = target.modelId;
-      if (normalized.stream !== void 0) {
-        providerBody.stream = normalized.stream;
+      if (Object.prototype.hasOwnProperty.call(payload, "stream")) {
+        providerBody.stream = Boolean(payload.stream);
       }
       const collected = {};
       const skip = /* @__PURE__ */ new Set(["content-length", "host", "connection", "transfer-encoding"]);
@@ -17575,15 +17659,15 @@ async function handleAnthropicProtocol(request, reply, endpoint, endpointId, app
       const json = await new Response(upstream.body).json();
       const inputTokens = json.usage?.input_tokens ?? estimateTokens(normalized, target.modelId);
       const outputTokens = json.usage?.output_tokens ?? 0;
-      const cached = resolveCachedTokens3(json.usage);
-      const cachedTokens = cached.read + cached.creation;
+      const cached2 = resolveCachedTokens3(json.usage);
+      const cachedTokens2 = cached2.read + cached2.creation;
       const latencyMs = Date.now() - requestStart;
       await updateLogTokens(logId, {
         inputTokens,
         outputTokens,
-        cachedTokens: usageCached,
-        cacheReadTokens: cached.read,
-        cacheCreationTokens: cached.creation,
+        cachedTokens: cachedTokens2,
+        cacheReadTokens: cached2.read,
+        cacheCreationTokens: cached2.creation,
         ttftMs: latencyMs,
         tpotMs: computeTpot3(latencyMs, outputTokens, { streaming: false })
       });
@@ -17592,9 +17676,9 @@ async function handleAnthropicProtocol(request, reply, endpoint, endpointId, app
         requests: 1,
         inputTokens,
         outputTokens,
-        cachedTokens: usageCached,
-        cacheReadTokens: usageCacheRead,
-        cacheCreationTokens: usageCacheCreation,
+        cachedTokens: cachedTokens2,
+        cacheReadTokens: cached2.read,
+        cacheCreationTokens: cached2.creation,
         latencyMs
       });
       if (storeResponsePayloads) {
@@ -17652,10 +17736,10 @@ async function handleAnthropicProtocol(request, reply, endpoint, endpointId, app
                 if (parsed?.usage) {
                   usagePrompt = parsed.usage.input_tokens ?? usagePrompt;
                   usageCompletion = parsed.usage.output_tokens ?? usageCompletion;
-                  const cached = resolveCachedTokens3(parsed.usage);
-                  usageCacheRead = cached.read;
-                  usageCacheCreation = cached.creation;
-                  usageCached = cached.read + cached.creation;
+                  const cached2 = resolveCachedTokens3(parsed.usage);
+                  usageCacheRead = cached2.read;
+                  usageCacheCreation = cached2.creation;
+                  usageCached = cached2.read + cached2.creation;
                 }
                 if (!firstTokenAt && (parsed?.type === "content_block_delta" || parsed?.delta?.text)) {
                   firstTokenAt = Date.now();
@@ -17851,7 +17935,9 @@ async function handleOpenAIChatProtocol(request, reply, endpoint, endpointId, ap
       });
     }
     providerBody.model = target.modelId;
-    providerBody.stream = normalized.stream;
+    if (Object.prototype.hasOwnProperty.call(payload, "stream")) {
+      providerBody.stream = Boolean(payload.stream);
+    }
     const upstream = await connector.send({
       model: target.modelId,
       body: providerBody,
@@ -17875,15 +17961,15 @@ async function handleOpenAIChatProtocol(request, reply, endpoint, endpointId, ap
       const usagePayload = json?.usage ?? null;
       const inputTokens2 = usagePayload?.prompt_tokens ?? usagePayload?.input_tokens ?? target.tokenEstimate ?? estimateTokens(normalized, target.modelId);
       const outputTokens2 = usagePayload?.completion_tokens ?? usagePayload?.output_tokens ?? estimateTextTokens(json?.choices?.[0]?.message?.content ?? "", target.modelId);
-      const cached = resolveCachedTokens3(usagePayload);
-      const cachedTokens = cached.read + cached.creation;
+      const cached2 = resolveCachedTokens3(usagePayload);
+      const cachedTokens2 = cached2.read + cached2.creation;
       const latencyMs2 = Date.now() - requestStart;
       await updateLogTokens(logId, {
         inputTokens: inputTokens2,
         outputTokens: outputTokens2,
-        cachedTokens: usageCached,
-        cacheReadTokens: cached.read,
-        cacheCreationTokens: cached.creation,
+        cachedTokens: cachedTokens2,
+        cacheReadTokens: cached2.read,
+        cacheCreationTokens: cached2.creation,
         ttftMs: latencyMs2,
         tpotMs: computeTpot3(latencyMs2, outputTokens2, { streaming: false })
       });
@@ -17892,9 +17978,9 @@ async function handleOpenAIChatProtocol(request, reply, endpoint, endpointId, ap
         requests: 1,
         inputTokens: inputTokens2,
         outputTokens: outputTokens2,
-        cachedTokens: usageCached,
-        cacheReadTokens: usageCacheRead,
-        cacheCreationTokens: usageCacheCreation,
+        cachedTokens: cachedTokens2,
+        cacheReadTokens: cached2.read,
+        cacheCreationTokens: cached2.creation,
         latencyMs: latencyMs2
       });
       if (storeResponsePayloads) {
@@ -18142,7 +18228,9 @@ async function handleOpenAIResponsesProtocol(request, reply, endpoint, endpointI
       });
     }
     providerBody.model = target.modelId;
-    providerBody.stream = normalized.stream;
+    if (Object.prototype.hasOwnProperty.call(payload, "stream")) {
+      providerBody.stream = Boolean(payload.stream);
+    }
     const upstream = await connector.send({
       model: target.modelId,
       body: providerBody,
@@ -18167,15 +18255,15 @@ async function handleOpenAIResponsesProtocol(request, reply, endpoint, endpointI
       const inputTokens2 = usagePayload?.prompt_tokens ?? usagePayload?.input_tokens ?? target.tokenEstimate ?? estimateTokens(normalized, target.modelId);
       const content = json?.response?.body?.content ?? json?.choices?.[0]?.message?.content ?? "";
       const outputTokens2 = usagePayload?.completion_tokens ?? usagePayload?.output_tokens ?? estimateTextTokens(content, target.modelId);
-      const cached = resolveCachedTokens3(usagePayload);
-      const cachedTokens = cached.read + cached.creation;
+      const cached2 = resolveCachedTokens3(usagePayload);
+      const cachedTokens2 = cached2.read + cached2.creation;
       const latencyMs2 = Date.now() - requestStart;
       await updateLogTokens(logId, {
         inputTokens: inputTokens2,
         outputTokens: outputTokens2,
-        cachedTokens: usageCached,
-        cacheReadTokens: cached.read,
-        cacheCreationTokens: cached.creation,
+        cachedTokens: cachedTokens2,
+        cacheReadTokens: cached2.read,
+        cacheCreationTokens: cached2.creation,
         ttftMs: latencyMs2,
         tpotMs: computeTpot3(latencyMs2, outputTokens2, { streaming: false })
       });
@@ -18184,9 +18272,9 @@ async function handleOpenAIResponsesProtocol(request, reply, endpoint, endpointI
         requests: 1,
         inputTokens: inputTokens2,
         outputTokens: outputTokens2,
-        cachedTokens: usageCached,
-        cacheReadTokens: usageCacheRead,
-        cacheCreationTokens: usageCacheCreation,
+        cachedTokens: cachedTokens2,
+        cacheReadTokens: cached2.read,
+        cacheCreationTokens: cached2.creation,
         latencyMs: latencyMs2
       });
       if (storeResponsePayloads) {
@@ -18316,11 +18404,11 @@ function startMaintenanceTimers() {
   scheduleCleanup();
 }
 function scheduleCleanup() {
-  const run2 = () => {
+  const run2 = async () => {
     try {
       const retentionDays = getConfig().logRetentionDays ?? 30;
       const cutoff = Date.now() - retentionDays * DAY_MS;
-      const deleted = cleanupLogsBefore(cutoff);
+      const deleted = await cleanupLogsBefore(cutoff);
       if (deleted > 0) {
         console.info(`[maintenance] cleaned ${deleted} old log entries`);
       }
@@ -18451,17 +18539,30 @@ async function syncCustomEndpoints(app, config) {
     );
   }
 }
-async function createServer() {
+async function createServer(protocol = "http") {
   const config = cachedConfig2 ?? loadConfig();
   const requestLogEnabled = config.requestLogging !== false;
   const responseLogEnabled = config.responseLogging !== false;
   const bodyLimit = typeof config.bodyLimit === "number" && Number.isFinite(config.bodyLimit) && config.bodyLimit > 0 ? config.bodyLimit : 10 * 1024 * 1024;
+  let httpsOptions;
+  if (protocol === "https" && config.https?.enabled) {
+    const { keyPath, certPath, caPath } = config.https;
+    if (!fs4.existsSync(keyPath) || !fs4.existsSync(certPath)) {
+      throw new Error(`HTTPS \u8BC1\u4E66\u6587\u4EF6\u4E0D\u5B58\u5728: ${keyPath}, ${certPath}`);
+    }
+    httpsOptions = {
+      key: fs4.readFileSync(keyPath),
+      cert: fs4.readFileSync(certPath),
+      ca: caPath ? fs4.readFileSync(caPath) : void 0
+    };
+  }
   const app = Fastify({
     logger: {
       level: config.logLevel ?? "info"
     },
     disableRequestLogging: true,
-    bodyLimit
+    bodyLimit,
+    https: httpsOptions
   });
   app.addHook("onRequest", async (request, reply) => {
     const authConfig = (cachedConfig2 ?? getConfig()).webAuth;
@@ -18602,25 +18703,54 @@ async function createServer() {
   return app;
 }
 async function startServer(options = {}) {
-  const app = await createServer();
-  const envPort = process2.env.PORT ? Number.parseInt(process2.env.PORT, 10) : void 0;
-  const envHost = process2.env.HOST;
-  const configPort = cachedConfig2?.port;
-  const configHost = cachedConfig2?.host;
-  const port = options.port ?? envPort ?? configPort ?? DEFAULT_PORT;
-  const host = options.host ?? envHost ?? configHost ?? DEFAULT_HOST;
-  await app.listen({ port, host });
-  return app;
+  const config = cachedConfig2 ?? loadConfig();
+  const result = {};
+  if (config.http?.enabled !== false) {
+    const httpApp = await createServer("http");
+    const httpPort = options.port ?? (process2.env.PORT ? Number.parseInt(process2.env.PORT, 10) : config.http?.port ?? config.port ?? DEFAULT_PORT);
+    const httpHost = options.host ?? process2.env.HOST ?? config.http?.host ?? config.host ?? DEFAULT_HOST;
+    await httpApp.listen({ port: httpPort, host: httpHost });
+    httpApp.log.info(`HTTP server started at http://${httpHost}:${httpPort}`);
+    result.http = httpApp;
+  }
+  if (config.https?.enabled === true) {
+    try {
+      const httpsApp = await createServer("https");
+      const httpsPort = config.https.port;
+      const httpsHost = config.https.host ?? config.host ?? DEFAULT_HOST;
+      await httpsApp.listen({ port: httpsPort, host: httpsHost });
+      httpsApp.log.info(`HTTPS server started at https://${httpsHost}:${httpsPort}`);
+      result.https = httpsApp;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error(`HTTPS server\u542F\u52A8\u5931\u8D25: ${errorMessage}`);
+      if (!result.http) {
+        throw error;
+      }
+      console.warn("\u4EC5 HTTP \u670D\u52A1\u5668\u542F\u52A8\u6210\u529F,HTTPS \u670D\u52A1\u5668\u542F\u52A8\u5931\u8D25");
+    }
+  }
+  if (!result.http && !result.https) {
+    throw new Error("HTTP \u548C HTTPS \u670D\u52A1\u5668\u5747\u672A\u542F\u52A8");
+  }
+  return result;
 }
 async function main() {
   try {
-    const app = await startServer();
+    const servers = await startServer();
     const shutdown = async () => {
       try {
-        await app.close();
+        const closePromises = [];
+        if (servers.http) {
+          closePromises.push(servers.http.close());
+        }
+        if (servers.https) {
+          closePromises.push(servers.https.close());
+        }
+        await Promise.all(closePromises);
         process2.exit(0);
       } catch (err) {
-        app.log.error({ err }, "\u5173\u95ED\u670D\u52A1\u5931\u8D25");
+        console.error("\u5173\u95ED\u670D\u52A1\u5931\u8D25:", err);
         process2.exit(1);
       }
     };