@chenpu17/cc-gw 0.2.1 → 0.2.3

package/src/server/dist/index.js

@@ -12,6 +12,14 @@ import fs from "fs";
 import path from "path";
 import os from "os";
 import { EventEmitter } from "events";
+var LOG_LEVELS = /* @__PURE__ */ new Set([
+  "fatal",
+  "error",
+  "warn",
+  "info",
+  "debug",
+  "trace"
+]);
 var HOME_DIR = path.join(os.homedir(), ".cc-gw");
 var CONFIG_PATH = path.join(HOME_DIR, "config.json");
 var TypedEmitter = class extends EventEmitter {
@@ -66,6 +74,12 @@ function parseConfig(raw) {
     }
     data.modelRoutes = sanitized;
   }
+  if (typeof data.logLevel !== "string" || !LOG_LEVELS.has(data.logLevel)) {
+    data.logLevel = "info";
+  }
+  if (typeof data.requestLogging !== "boolean") {
+    data.requestLogging = true;
+  }
   return data;
 }
 function loadConfig() {
@@ -723,6 +737,8 @@ function buildConnector(config) {
   switch (config.type) {
     case "deepseek":
       return createDeepSeekConnector(config);
+    case "huawei":
+      return createOpenAIConnector(config);
     case "kimi":
       return createKimiConnector(config);
     case "anthropic":
@@ -754,20 +770,93 @@ import { brotliCompressSync, brotliDecompressSync, constants as zlibConstants }
 import fs2 from "fs";
 import os2 from "os";
 import path2 from "path";
-import Database from "better-sqlite3";
+import sqlite3 from "sqlite3";
 var HOME_DIR2 = path2.join(os2.homedir(), ".cc-gw");
 var DATA_DIR = path2.join(HOME_DIR2, "data");
 var DB_PATH = path2.join(DATA_DIR, "gateway.db");
-var db = null;
-function ensureSchema(instance) {
-  instance.exec(`
-    CREATE TABLE IF NOT EXISTS request_logs (
+sqlite3.verbose();
+var dbPromise = null;
+var dbInstance = null;
+function exec(db, sql) {
+  return new Promise((resolve, reject) => {
+    db.exec(sql, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+function run(db, sql, params = []) {
+  return new Promise((resolve, reject) => {
+    const handler = function(error) {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve({ lastID: this.lastID, changes: this.changes });
+    };
+    if (Array.isArray(params)) {
+      db.run(sql, params, handler);
+    } else {
+      db.run(sql, params, handler);
+    }
+  });
+}
+function all(db, sql, params = []) {
+  return new Promise((resolve, reject) => {
+    const callback = (error, rows) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve(rows);
+    };
+    if (Array.isArray(params)) {
+      db.all(sql, params, callback);
+    } else {
+      db.all(sql, params, callback);
+    }
+  });
+}
+function get(db, sql, params = []) {
+  return new Promise((resolve, reject) => {
+    const callback = (error, row) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve(row);
+    };
+    if (Array.isArray(params)) {
+      db.get(sql, params, callback);
+    } else {
+      db.get(sql, params, callback);
+    }
+  });
+}
+async function columnExists(db, table, column) {
+  const rows = await all(db, `PRAGMA table_info(${table})`);
+  return rows.some((row) => row.name === column);
+}
+async function maybeAddColumn(db, table, column, definition) {
+  const exists = await columnExists(db, table, column);
+  if (!exists) {
+    await run(db, `ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+  }
+}
+async function ensureSchema(db) {
+  await exec(
+    db,
+    `CREATE TABLE IF NOT EXISTS request_logs (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       timestamp INTEGER NOT NULL,
       session_id TEXT,
       provider TEXT NOT NULL,
       model TEXT NOT NULL,
       client_model TEXT,
+      stream INTEGER,
       latency_ms INTEGER,
       status_code INTEGER,
       input_tokens INTEGER,
@@ -791,63 +880,51 @@ function ensureSchema(instance) {
       total_input_tokens INTEGER DEFAULT 0,
       total_output_tokens INTEGER DEFAULT 0,
       total_latency_ms INTEGER DEFAULT 0
-    );
-  `);
-}
-function getDb() {
-  if (db)
-    return db;
-  fs2.mkdirSync(DATA_DIR, { recursive: true });
-  db = new Database(DB_PATH);
-  ensureSchema(db);
-  ensureColumns(db);
-  return db;
+    );`
+  );
+  await maybeAddColumn(db, "request_logs", "client_model", "TEXT");
+  await maybeAddColumn(db, "request_logs", "cached_tokens", "INTEGER");
+  await maybeAddColumn(db, "request_logs", "ttft_ms", "INTEGER");
+  await maybeAddColumn(db, "request_logs", "tpot_ms", "REAL");
+  await maybeAddColumn(db, "request_logs", "stream", "INTEGER");
 }
-function ensureColumns(instance) {
-  const columns = instance.prepare("PRAGMA table_info(request_logs)").all();
-  const hasCachedTokens = columns.some((column) => column.name === "cached_tokens");
-  if (!hasCachedTokens) {
-    instance.exec("ALTER TABLE request_logs ADD COLUMN cached_tokens INTEGER");
-  }
-  const hasClientModel = columns.some((column) => column.name === "client_model");
-  if (!hasClientModel) {
-    instance.exec("ALTER TABLE request_logs ADD COLUMN client_model TEXT");
-  }
-  const hasTtft = columns.some((column) => column.name === "ttft_ms");
-  if (!hasTtft) {
-    instance.exec("ALTER TABLE request_logs ADD COLUMN ttft_ms INTEGER");
-  }
-  const hasTpot = columns.some((column) => column.name === "tpot_ms");
-  if (!hasTpot) {
-    instance.exec("ALTER TABLE request_logs ADD COLUMN tpot_ms REAL");
+async function getDb() {
+  if (dbInstance) {
+    return dbInstance;
+  }
+  if (!dbPromise) {
+    fs2.mkdirSync(DATA_DIR, { recursive: true });
+    dbPromise = new Promise((resolve, reject) => {
+      const instance = new sqlite3.Database(DB_PATH, (error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        ensureSchema(instance).then(() => {
+          dbInstance = instance;
+          resolve(instance);
+        }).catch((schemaError) => {
+          instance.close(() => reject(schemaError));
+        });
+      });
+    });
   }
+  return dbPromise;
+}
+async function runQuery(sql, params = []) {
+  const db = await getDb();
+  return run(db, sql, params);
+}
+async function getOne(sql, params = []) {
+  const db = await getDb();
+  return get(db, sql, params);
+}
+async function getAll(sql, params = []) {
+  const db = await getDb();
+  return all(db, sql, params);
 }
 
 // logging/logger.ts
-function recordLog(entry) {
-  const db2 = getDb();
-  const stmt = db2.prepare(`
-    INSERT INTO request_logs (
-      timestamp, session_id, provider, model, client_model,
-      latency_ms, status_code, input_tokens, output_tokens, cached_tokens, error
-    ) VALUES (@timestamp, @sessionId, @provider, @model, @clientModel, @latencyMs, @statusCode, @inputTokens, @outputTokens, @cachedTokens, @error)
-  `);
-  const result = stmt.run({
-    timestamp: entry.timestamp,
-    sessionId: entry.sessionId ?? null,
-    provider: entry.provider,
-    model: entry.model,
-    clientModel: entry.clientModel ?? null,
-    latencyMs: entry.latencyMs ?? null,
-    statusCode: entry.statusCode ?? null,
-    inputTokens: entry.inputTokens ?? null,
-    outputTokens: entry.outputTokens ?? null,
-    cachedTokens: entry.cachedTokens ?? null,
-    error: entry.error ?? null
-  });
-  const requestId = Number(result.lastInsertRowid);
-  return requestId;
-}
 var BROTLI_OPTIONS = {
   params: {
     [zlibConstants.BROTLI_PARAM_QUALITY]: 1
@@ -874,16 +951,37 @@ function decompressPayload(value) {
       return "";
     }
     try {
-      const decompressed = brotliDecompressSync(value);
-      return decompressed.toString("utf8");
+      return brotliDecompressSync(value).toString("utf8");
     } catch {
       return value.toString("utf8");
     }
   }
   return null;
 }
-function updateLogTokens(requestId, values) {
-  const db2 = getDb();
+async function recordLog(entry) {
+  const result = await runQuery(
+    `INSERT INTO request_logs (
+      timestamp, session_id, provider, model, client_model, stream,
+      latency_ms, status_code, input_tokens, output_tokens, cached_tokens, error
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [
+      entry.timestamp,
+      entry.sessionId ?? null,
+      entry.provider,
+      entry.model,
+      entry.clientModel ?? null,
+      entry.stream ? 1 : 0,
+      entry.latencyMs ?? null,
+      entry.statusCode ?? null,
+      entry.inputTokens ?? null,
+      entry.outputTokens ?? null,
+      entry.cachedTokens ?? null,
+      entry.error ?? null
+    ]
+  );
+  return Number(result.lastID);
+}
+async function updateLogTokens(requestId, values) {
   const setters = ["input_tokens = ?", "output_tokens = ?", "cached_tokens = ?"];
   const params = [
     values.inputTokens,
@@ -898,10 +996,10 @@ function updateLogTokens(requestId, values) {
     setters.push("tpot_ms = ?");
     params.push(values.tpotMs ?? null);
   }
-  db2.prepare(`UPDATE request_logs SET ${setters.join(", ")} WHERE id = ?`).run(...params, requestId);
+  params.push(requestId);
+  await runQuery(`UPDATE request_logs SET ${setters.join(", ")} WHERE id = ?`, params);
 }
-function finalizeLog(requestId, info) {
-  const db2 = getDb();
+async function finalizeLog(requestId, info) {
   const setters = [];
   const values = [];
   if (info.latencyMs !== void 0) {
@@ -922,45 +1020,41 @@ function finalizeLog(requestId, info) {
   }
   if (setters.length === 0)
     return;
-  const stmt = db2.prepare(`UPDATE request_logs SET ${setters.join(", ")} WHERE id = ?`);
-  stmt.run(...values, requestId);
+  values.push(requestId);
+  await runQuery(`UPDATE request_logs SET ${setters.join(", ")} WHERE id = ?`, values);
 }
-function upsertLogPayload(requestId, payload) {
+async function upsertLogPayload(requestId, payload) {
   if (payload.prompt === void 0 && payload.response === void 0) {
     return;
   }
-  const db2 = getDb();
   const promptData = payload.prompt === void 0 ? null : compressPayload(payload.prompt);
   const responseData = payload.response === void 0 ? null : compressPayload(payload.response);
-  db2.prepare(`
-    INSERT INTO request_payloads (request_id, prompt, response)
-    VALUES (?, ?, ?)
-    ON CONFLICT(request_id) DO UPDATE SET
-      prompt = COALESCE(excluded.prompt, request_payloads.prompt),
-      response = COALESCE(excluded.response, request_payloads.response)
-  `).run(
-    requestId,
-    promptData,
-    responseData
+  await runQuery(
+    `INSERT INTO request_payloads (request_id, prompt, response)
+     VALUES (?, ?, ?)
+     ON CONFLICT(request_id) DO UPDATE SET
+       prompt = COALESCE(excluded.prompt, request_payloads.prompt),
+       response = COALESCE(excluded.response, request_payloads.response)`,
+    [requestId, promptData, responseData]
   );
 }
-function updateMetrics(date, delta) {
-  const db2 = getDb();
-  db2.prepare(`
-    INSERT INTO daily_metrics (date, request_count, total_input_tokens, total_output_tokens, total_latency_ms)
-    VALUES (@date, @requests, @inputTokens, @outputTokens, @latencyMs)
-    ON CONFLICT(date) DO UPDATE SET
-      request_count = daily_metrics.request_count + excluded.request_count,
-      total_input_tokens = daily_metrics.total_input_tokens + excluded.total_input_tokens,
-      total_output_tokens = daily_metrics.total_output_tokens + excluded.total_output_tokens,
-      total_latency_ms = daily_metrics.total_latency_ms + excluded.total_latency_ms
-  `).run({
-    date,
-    requests: delta.requests,
-    inputTokens: delta.inputTokens,
-    outputTokens: delta.outputTokens,
-    latencyMs: delta.latencyMs
-  });
+async function updateMetrics(date, delta) {
+  await runQuery(
+    `INSERT INTO daily_metrics (date, request_count, total_input_tokens, total_output_tokens, total_latency_ms)
+     VALUES (?, ?, ?, ?, ?)
+     ON CONFLICT(date) DO UPDATE SET
+       request_count = daily_metrics.request_count + excluded.request_count,
+       total_input_tokens = daily_metrics.total_input_tokens + excluded.total_input_tokens,
+       total_output_tokens = daily_metrics.total_output_tokens + excluded.total_output_tokens,
+       total_latency_ms = daily_metrics.total_latency_ms + excluded.total_latency_ms`,
+    [
+      date,
+      delta.requests,
+      delta.inputTokens,
+      delta.outputTokens,
+      delta.latencyMs
+    ]
+  );
 }
 
 // metrics/activity.ts
@@ -990,6 +1084,79 @@ function mapStopReason(reason) {
       return reason ?? null;
   }
 }
+function stringifyToolContent(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+function mergeText(base, extraParts) {
+  const parts = [];
+  if (base && base.trim().length > 0) {
+    parts.push(base);
+  }
+  for (const part of extraParts) {
+    if (part && part.trim().length > 0) {
+      parts.push(part);
+    }
+  }
+  return parts.join("\n\n");
+}
+function stripTooling(payload) {
+  const messages = payload.messages.map((message) => {
+    if (message.role === "user") {
+      const extras = (message.toolResults ?? []).map((result) => {
+        const label = result.name || result.id;
+        const content = stringifyToolContent(result.content);
+        return label ? `${label}${content ? `
+${content}` : ""}` : content;
+      });
+      return {
+        role: message.role,
+        text: mergeText(message.text, extras)
+      };
+    }
+    if (message.role === "assistant") {
+      const extras = (message.toolCalls ?? []).map((call) => {
+        const label = call.name || call.id;
+        const args = stringifyToolContent(call.arguments);
+        return label ? `Requested tool ${label}${args ? `
+${args}` : ""}` : args;
+      });
+      return {
+        role: message.role,
+        text: mergeText(message.text, extras)
+      };
+    }
+    return {
+      role: message.role,
+      text: message.text
+    };
+  });
+  return {
+    ...payload,
+    messages,
+    tools: []
+  };
+}
+function stripMetadata(payload) {
+  const original = payload.original;
+  if (!original || typeof original !== "object") {
+    return payload;
+  }
+  const { metadata, ...rest } = original;
+  return {
+    ...payload,
+    original: rest
+  };
+}
 var roundTwoDecimals = (value) => Math.round(value * 100) / 100;
 function computeTpot(totalLatencyMs, outputTokens, options) {
   if (!Number.isFinite(outputTokens) || outputTokens <= 0) {
@@ -1015,8 +1182,21 @@ function resolveCachedTokens(usage) {
   if (promptDetails && typeof promptDetails.cached_tokens === "number") {
     return promptDetails.cached_tokens;
   }
+  if (typeof usage.cache_read_input_tokens === "number") {
+    return usage.cache_read_input_tokens;
+  }
+  if (typeof usage.cache_creation_input_tokens === "number") {
+    return usage.cache_creation_input_tokens;
+  }
   return null;
 }
+function cloneOriginalPayload(value) {
+  const structuredCloneFn = globalThis.structuredClone;
+  if (structuredCloneFn) {
+    return structuredCloneFn(value);
+  }
+  return JSON.parse(JSON.stringify(value));
+}
 function buildClaudeResponse(openAI, model) {
   const choice = openAI.choices?.[0];
   const message = choice?.message ?? {};
@@ -1061,6 +1241,16 @@ async function registerMessagesRoute(app) {
       reply.code(400);
       return { error: "Invalid request body" };
     }
+    const rawUrl = typeof request.raw?.url === "string" ? request.raw.url : request.url ?? "";
+    let querySuffix = null;
+    if (typeof rawUrl === "string" && rawUrl.includes("?")) {
+      querySuffix = rawUrl.slice(rawUrl.indexOf("?"));
+    } else if (typeof request.querystring === "string" && request.querystring.length > 0) {
+      querySuffix = `?${request.querystring}`;
+    }
+    if (querySuffix) {
+      console.info(`[cc-gw] inbound url ${rawUrl} query ${querySuffix}`);
+    }
     const normalized = normalizeClaudePayload(payload);
     const requestedModel = typeof payload.model === "string" ? payload.model : void 0;
     const target = resolveRoute({
@@ -1068,30 +1258,69 @@ async function registerMessagesRoute(app) {
       requestedModel
     });
     const providerType = target.provider.type ?? "custom";
-    const providerBody = providerType === "anthropic" ? buildAnthropicBody(normalized, {
-      maxTokens: payload.max_tokens ?? target.provider.models?.find((m) => m.id === target.modelId)?.maxTokens,
-      temperature: payload.temperature,
-      toolChoice: payload.tool_choice,
-      overrideTools: payload.tools
-    }) : buildProviderBody(normalized, {
-      maxTokens: payload.max_tokens ?? target.provider.models?.find((m) => m.id === target.modelId)?.maxTokens,
-      temperature: payload.temperature,
-      toolChoice: payload.tool_choice,
-      overrideTools: payload.tools
-    });
+    const modelDefinition = target.provider.models?.find((m) => m.id === target.modelId);
+    const supportsTools = modelDefinition?.capabilities?.tools === true;
+    const supportsMetadata = providerType !== "custom";
+    let normalizedForProvider = supportsTools ? normalized : stripTooling(normalized);
+    if (!supportsMetadata) {
+      normalizedForProvider = stripMetadata(normalizedForProvider);
+    }
+    const maxTokensOverride = payload.max_tokens ?? modelDefinition?.maxTokens;
+    const toolChoice = supportsTools ? payload.tool_choice : void 0;
+    const overrideTools = supportsTools ? payload.tools : void 0;
+    let providerBody;
+    let providerHeaders;
+    if (providerType === "anthropic") {
+      providerBody = cloneOriginalPayload(payload);
+      providerBody.model = target.modelId;
+      if (normalized.stream !== void 0) {
+        providerBody.stream = normalized.stream;
+      }
+      const collected = {};
+      const skip = /* @__PURE__ */ new Set(["content-length", "host", "connection", "transfer-encoding"]);
+      const sourceHeaders = request.raw?.headers ?? request.headers;
+      for (const [headerKey, headerValue] of Object.entries(sourceHeaders)) {
+        const lower = headerKey.toLowerCase();
+        if (skip.has(lower))
+          continue;
+        let value;
+        if (typeof headerValue === "string") {
+          value = headerValue;
+        } else if (Array.isArray(headerValue)) {
+          value = headerValue.find((item) => typeof item === "string" && item.length > 0);
+        }
+        if (value && value.length > 0) {
+          collected[lower] = value;
+        }
+      }
+      if (!("content-type" in collected)) {
+        collected["content-type"] = "application/json";
+      }
+      if (Object.keys(collected).length > 0) {
+        providerHeaders = collected;
+      }
+    } else {
+      providerBody = buildProviderBody(normalizedForProvider, {
+        maxTokens: maxTokensOverride,
+        temperature: payload.temperature,
+        toolChoice,
+        overrideTools
+      });
+    }
     const connector = getConnector(target.providerId);
     const requestStart = Date.now();
     const storePayloads = getConfig().storePayloads !== false;
-    const logId = recordLog({
+    const logId = await recordLog({
       timestamp: requestStart,
       provider: target.providerId,
       model: target.modelId,
       clientModel: requestedModel,
-      sessionId: payload.metadata?.user_id
+      sessionId: payload.metadata?.user_id,
+      stream: normalized.stream
     });
     incrementActiveRequests();
     if (storePayloads) {
-      upsertLogPayload(logId, {
+      await upsertLogPayload(logId, {
         prompt: (() => {
           try {
             return JSON.stringify(payload);
@@ -1102,10 +1331,10 @@ async function registerMessagesRoute(app) {
       });
     }
     let finalized = false;
-    const finalize = (statusCode, error) => {
+    const finalize = async (statusCode, error) => {
       if (finalized)
         return;
-      finalizeLog(logId, {
+      await finalizeLog(logId, {
         latencyMs: Date.now() - requestStart,
         statusCode,
         error,
@@ -1136,16 +1365,21 @@ async function registerMessagesRoute(app) {
       const upstream = await connector.send({
         model: target.modelId,
         body: providerBody,
-        stream: normalized.stream
+        stream: normalized.stream,
+        query: querySuffix,
+        headers: providerHeaders
       });
       if (upstream.status >= 400) {
         reply.code(upstream.status);
         const bodyText = upstream.body ? await new Response(upstream.body).text() : "";
         const errorText = bodyText || "Upstream provider error";
+        console.warn(
+          `[cc-gw][provider:${target.providerId}] upstream error status=${upstream.status} body=${bodyText || "<empty>"}`
+        );
         if (storePayloads) {
-          upsertLogPayload(logId, { response: bodyText || null });
+          await upsertLogPayload(logId, { response: bodyText || null });
         }
-        finalize(upstream.status, errorText);
+        await finalize(upstream.status, errorText);
         return { error: errorText };
       }
       if (!normalized.stream) {
@@ -1167,21 +1401,21 @@ async function registerMessagesRoute(app) {
             cached: cachedTokens2
           });
           const latencyMs2 = Date.now() - requestStart;
-          updateLogTokens(logId, {
+          await updateLogTokens(logId, {
             inputTokens: inputTokens2,
             outputTokens: outputTokens2,
             cachedTokens: cachedTokens2,
             ttftMs: latencyMs2,
             tpotMs: computeTpot(latencyMs2, outputTokens2, { streaming: false })
           });
-          updateMetrics((/* @__PURE__ */ new Date()).toISOString().slice(0, 10), {
+          await updateMetrics((/* @__PURE__ */ new Date()).toISOString().slice(0, 10), {
             requests: 1,
             inputTokens: inputTokens2,
             outputTokens: outputTokens2,
             latencyMs: latencyMs2
           });
           if (storePayloads) {
-            upsertLogPayload(logId, {
+            await upsertLogPayload(logId, {
               response: (() => {
                 try {
                   return JSON.stringify(json);
@@ -1191,7 +1425,7 @@ async function registerMessagesRoute(app) {
               })()
             });
           }
-          finalize(200, null);
+          await finalize(200, null);
           reply.header("content-type", "application/json");
           return json;
         }
@@ -1212,21 +1446,21 @@ async function registerMessagesRoute(app) {
           cached: cachedTokens
         });
         const latencyMs = Date.now() - requestStart;
-        updateLogTokens(logId, {
+        await updateLogTokens(logId, {
           inputTokens,
           outputTokens,
           cachedTokens,
           ttftMs: latencyMs,
           tpotMs: computeTpot(latencyMs, outputTokens, { streaming: false })
         });
-        updateMetrics((/* @__PURE__ */ new Date()).toISOString().slice(0, 10), {
+        await updateMetrics((/* @__PURE__ */ new Date()).toISOString().slice(0, 10), {
           requests: 1,
           inputTokens,
           outputTokens,
           latencyMs
         });
         if (storePayloads) {
-          upsertLogPayload(logId, {
+          await upsertLogPayload(logId, {
             response: (() => {
               try {
                 return JSON.stringify(claudeResponse);
@@ -1236,18 +1470,19 @@ async function registerMessagesRoute(app) {
             })()
           });
         }
-        finalize(200, null);
+        await finalize(200, null);
         reply.header("content-type", "application/json");
         return claudeResponse;
       }
       if (!upstream.body) {
         reply.code(500);
-        finalize(500, "Upstream returned empty body");
+        await finalize(500, "Upstream returned empty body");
         return { error: "Upstream returned empty body" };
       }
       reply.header("content-type", "text/event-stream; charset=utf-8");
       reply.header("cache-control", "no-cache, no-store, must-revalidate");
       reply.header("connection", "keep-alive");
+      reply.hijack();
       reply.raw.writeHead(200);
       if (providerType === "anthropic") {
         const reader2 = upstream.body.getReader();
@@ -1258,6 +1493,8 @@ async function registerMessagesRoute(app) {
         let usageCompletion2 = 0;
         let usageCached2 = null;
         let accumulatedContent2 = "";
+        let firstTokenAt2 = null;
+        let lastUsagePayload = null;
         while (true) {
           const { value, done } = await reader2.read();
           if (done)
@@ -1280,12 +1517,17 @@ async function registerMessagesRoute(app) {
                   if (data?.usage) {
                     usagePrompt2 = data.usage.input_tokens ?? usagePrompt2;
                     usageCompletion2 = data.usage.output_tokens ?? usageCompletion2;
-                    if (typeof data.usage.cached_tokens === "number") {
-                      usageCached2 = data.usage.cached_tokens;
+                    const maybeCached = resolveCachedTokens(data.usage);
+                    if (maybeCached !== null) {
+                      usageCached2 = maybeCached;
                     }
+                    lastUsagePayload = data.usage;
                   }
                   const deltaText = data?.delta?.text;
                   if (typeof deltaText === "string") {
+                    if (!firstTokenAt2 && deltaText.length > 0) {
+                      firstTokenAt2 = Date.now();
+                    }
                     accumulatedContent2 += deltaText;
                   }
                 } catch (error) {
@@ -1307,14 +1549,20 @@ async function registerMessagesRoute(app) {
         if (!usageCompletion2) {
           usageCompletion2 = accumulatedContent2 ? estimateTextTokens(accumulatedContent2, target.modelId) : estimateTextTokens("", target.modelId);
         }
+        if (!firstTokenAt2) {
+          firstTokenAt2 = requestStart;
+        }
         const totalLatencyMs = Date.now() - requestStart;
-        const ttftMs = firstTokenAt ? firstTokenAt - requestStart : null;
+        const ttftMs = firstTokenAt2 ? firstTokenAt2 - requestStart : null;
+        if (usageCached2 === null) {
+          usageCached2 = resolveCachedTokens(lastUsagePayload);
+        }
         logUsage("stream.anthropic.final", {
           input: usagePrompt2,
           output: usageCompletion2,
           cached: usageCached2
         });
-        updateLogTokens(logId, {
+        await updateLogTokens(logId, {
           inputTokens: usagePrompt2,
           outputTokens: usageCompletion2,
           cachedTokens: usageCached2,
@@ -1324,14 +1572,14 @@ async function registerMessagesRoute(app) {
             ttftMs
           })
         });
-        updateMetrics((/* @__PURE__ */ new Date()).toISOString().slice(0, 10), {
+        await updateMetrics((/* @__PURE__ */ new Date()).toISOString().slice(0, 10), {
           requests: 1,
           inputTokens: usagePrompt2,
           outputTokens: usageCompletion2,
           latencyMs: totalLatencyMs
         });
         if (storePayloads) {
-          upsertLogPayload(logId, {
+          await upsertLogPayload(logId, {
             response: (() => {
               try {
                 return JSON.stringify({
@@ -1348,7 +1596,7 @@ async function registerMessagesRoute(app) {
             })()
           });
         }
-        finalize(200, null);
+        await finalize(200, null);
         return reply;
       }
       const reader = upstream.body.getReader();
@@ -1438,7 +1686,7 @@ data: ${JSON.stringify(data)}
               output: finalCompletionTokens,
               cached: usageCached
             });
-            updateLogTokens(logId, {
+            await updateLogTokens(logId, {
               inputTokens: finalPromptTokens,
               outputTokens: finalCompletionTokens,
               cachedTokens: usageCached,
@@ -1448,14 +1696,14 @@ data: ${JSON.stringify(data)}
                 ttftMs
               })
             });
-            updateMetrics((/* @__PURE__ */ new Date()).toISOString().slice(0, 10), {
+            await updateMetrics((/* @__PURE__ */ new Date()).toISOString().slice(0, 10), {
               requests: 1,
               inputTokens: finalPromptTokens,
               outputTokens: finalCompletionTokens,
               latencyMs: totalLatencyMs
             });
             if (storePayloads) {
-              upsertLogPayload(logId, {
+              await upsertLogPayload(logId, {
                 response: (() => {
                   try {
                     return JSON.stringify({
@@ -1473,7 +1721,7 @@ data: ${JSON.stringify(data)}
                 })()
               });
             }
-            finalize(200, null);
+            await finalize(200, null);
             completed = true;
             return reply;
           }
@@ -1495,6 +1743,7 @@ data: ${JSON.stringify(data)}
             }
           }
           if (choice.delta?.tool_calls) {
+            request.log.debug({ event: "debug.tool_call_delta", delta: choice.delta?.tool_calls }, "tool call delta received");
             if (!firstTokenAt) {
               firstTokenAt = Date.now();
             }
@@ -1582,6 +1831,9 @@ data: ${JSON.stringify(data)}
       }
       if (!completed) {
         reply.raw.end();
+        if (!firstTokenAt) {
+          firstTokenAt = requestStart;
+        }
         const totalLatencyMs = Date.now() - requestStart;
         const fallbackPrompt = usagePrompt || target.tokenEstimate || estimateTokens(normalized, target.modelId);
         const fallbackCompletion = usageCompletion || estimateTextTokens(accumulatedContent, target.modelId);
@@ -1591,7 +1843,7 @@ data: ${JSON.stringify(data)}
           output: fallbackCompletion,
           cached: usageCached
         });
-        updateLogTokens(logId, {
+        await updateLogTokens(logId, {
           inputTokens: fallbackPrompt,
           outputTokens: fallbackCompletion,
           cachedTokens: usageCached,
@@ -1601,14 +1853,14 @@ data: ${JSON.stringify(data)}
             ttftMs
           })
         });
-        updateMetrics((/* @__PURE__ */ new Date()).toISOString().slice(0, 10), {
+        await updateMetrics((/* @__PURE__ */ new Date()).toISOString().slice(0, 10), {
           requests: 1,
           inputTokens: fallbackPrompt,
           outputTokens: fallbackCompletion,
           latencyMs: totalLatencyMs
         });
         if (storePayloads) {
-          upsertLogPayload(logId, {
+          await upsertLogPayload(logId, {
             response: (() => {
               try {
                 return JSON.stringify({
@@ -1625,7 +1877,7 @@ data: ${JSON.stringify(data)}
             })()
           });
         }
-        finalize(200, null);
+        await finalize(200, null);
         return reply;
       }
     } catch (err) {
@@ -1633,31 +1885,30 @@ data: ${JSON.stringify(data)}
       if (!reply.sent) {
         reply.code(500);
       }
-      finalize(reply.statusCode >= 400 ? reply.statusCode : 500, message);
+      await finalize(reply.statusCode >= 400 ? reply.statusCode : 500, message);
       return { error: message };
     } finally {
       decrementActiveRequests();
       if (!finalized && reply.sent) {
-        finalize(reply.statusCode ?? 200, null);
+        await finalize(reply.statusCode ?? 200, null);
       }
     }
   });
 }
 
 // logging/queries.ts
-function queryLogs(options = {}) {
-  const db2 = getDb();
+async function queryLogs(options = {}) {
   const limit = Math.min(Math.max(options.limit ?? 50, 1), 200);
   const offset = Math.max(options.offset ?? 0, 0);
   const conditions = [];
   const params = {};
   if (options.provider) {
-    conditions.push("provider = @provider");
-    params.provider = options.provider;
+    conditions.push("provider = $provider");
+    params.$provider = options.provider;
   }
   if (options.model) {
-    conditions.push("model = @model");
-    params.model = options.model;
+    conditions.push("model = $model");
+    params.$model = options.model;
   }
   if (options.status === "success") {
     conditions.push("error IS NULL");
@@ -1665,39 +1916,49 @@ function queryLogs(options = {}) {
     conditions.push("error IS NOT NULL");
   }
   if (typeof options.from === "number") {
-    conditions.push("timestamp >= @from");
-    params.from = options.from;
+    conditions.push("timestamp >= $from");
+    params.$from = options.from;
   }
   if (typeof options.to === "number") {
-    conditions.push("timestamp <= @to");
-    params.to = options.to;
+    conditions.push("timestamp <= $to");
+    params.$to = options.to;
   }
   const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-  const totalRow = db2.prepare(`SELECT COUNT(*) AS count FROM request_logs ${whereClause}`).get(params);
-  const items = db2.prepare(
-    `SELECT id, timestamp, session_id, provider, model, client_model, latency_ms, status_code, input_tokens, output_tokens, cached_tokens, ttft_ms, tpot_ms, error
+  const totalRow = await getOne(
+    `SELECT COUNT(*) AS count FROM request_logs ${whereClause}`,
+    params
+  );
+  const items = await getAll(
+    `SELECT id, timestamp, session_id, provider, model, client_model,
+            stream, latency_ms, status_code, input_tokens, output_tokens,
+            cached_tokens, ttft_ms, tpot_ms, error
        FROM request_logs
        ${whereClause}
        ORDER BY timestamp DESC
-       LIMIT @limit OFFSET @offset`
-  ).all({ ...params, limit, offset });
+       LIMIT $limit OFFSET $offset`,
+    { ...params, $limit: limit, $offset: offset }
+  );
   return {
     total: totalRow?.count ?? 0,
     items
   };
 }
-function getLogDetail(id) {
-  const db2 = getDb();
-  const record = db2.prepare(
-    `SELECT id, timestamp, session_id, provider, model, client_model, latency_ms, status_code, input_tokens, output_tokens, cached_tokens, ttft_ms, tpot_ms, error
+async function getLogDetail(id) {
+  const record = await getOne(
+    `SELECT id, timestamp, session_id, provider, model, client_model,
+            stream, latency_ms, status_code, input_tokens, output_tokens,
+            cached_tokens, ttft_ms, tpot_ms, error
        FROM request_logs
-       WHERE id = ?`
-  ).get(id);
+       WHERE id = ?`,
+    [id]
+  );
   return record ?? null;
 }
-function getLogPayload(id) {
-  const db2 = getDb();
-  const payload = db2.prepare(`SELECT prompt, response FROM request_payloads WHERE request_id = ?`).get(id);
+async function getLogPayload(id) {
+  const payload = await getOne(
+    "SELECT prompt, response FROM request_payloads WHERE request_id = ?",
+    [id]
+  );
   if (!payload) {
     return null;
   }
@@ -1706,21 +1967,30 @@ function getLogPayload(id) {
     response: decompressPayload(payload.response)
   };
 }
-function cleanupLogsBefore(timestamp) {
-  const db2 = getDb();
-  const stmt = db2.prepare(`DELETE FROM request_logs WHERE timestamp < ?`);
-  const result = stmt.run(timestamp);
+async function cleanupLogsBefore(timestamp) {
+  const result = await runQuery("DELETE FROM request_logs WHERE timestamp < ?", [timestamp]);
   return Number(result.changes ?? 0);
 }
-function getDailyMetrics(days = 7) {
-  const db2 = getDb();
-  const rows = db2.prepare(
-    `SELECT date, request_count AS requestCount, total_input_tokens AS inputTokens,
-              total_output_tokens AS outputTokens, total_latency_ms AS totalLatency
-         FROM daily_metrics
-         ORDER BY date DESC
-         LIMIT ?`
-  ).all(days);
+async function clearAllLogs() {
+  const logsResult = await runQuery("DELETE FROM request_logs", []);
+  const metricsResult = await runQuery("DELETE FROM daily_metrics", []);
+  return {
+    logs: Number(logsResult.changes ?? 0),
+    metrics: Number(metricsResult.changes ?? 0)
+  };
+}
+async function getDailyMetrics(days = 7) {
+  const rows = await getAll(
+    `SELECT date,
+            request_count AS requestCount,
+            total_input_tokens AS inputTokens,
+            total_output_tokens AS outputTokens,
+            total_latency_ms AS totalLatency
+       FROM daily_metrics
+       ORDER BY date DESC
+       LIMIT ?`,
+    [days]
+  );
   return rows.map((row) => ({
     date: row.date,
     requestCount: row.requestCount ?? 0,
@@ -1729,34 +1999,35 @@ function getDailyMetrics(days = 7) {
     avgLatencyMs: row.requestCount ? Math.round((row.totalLatency ?? 0) / row.requestCount) : 0
   })).reverse();
 }
-function getMetricsOverview() {
-  const db2 = getDb();
-  const totalsRow = db2.prepare(
+async function getMetricsOverview() {
+  const totalsRow = await getOne(
     `SELECT
-         COALESCE(SUM(request_count), 0) AS requests,
-         COALESCE(SUM(total_input_tokens), 0) AS inputTokens,
-         COALESCE(SUM(total_output_tokens), 0) AS outputTokens,
-         COALESCE(SUM(total_latency_ms), 0) AS totalLatency
-       FROM daily_metrics`
-  ).get();
+       COALESCE(SUM(request_count), 0) AS requests,
+       COALESCE(SUM(total_input_tokens), 0) AS inputTokens,
+       COALESCE(SUM(total_output_tokens), 0) AS outputTokens,
+       COALESCE(SUM(total_latency_ms), 0) AS totalLatency
+     FROM daily_metrics`
+  );
   const todayKey = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const todayRow = db2.prepare(
+  const todayRow = await getOne(
     `SELECT request_count AS requests,
-              total_input_tokens AS inputTokens,
-              total_output_tokens AS outputTokens,
-              total_latency_ms AS totalLatency
-         FROM daily_metrics WHERE date = ?`
-  ).get(todayKey);
+            total_input_tokens AS inputTokens,
+            total_output_tokens AS outputTokens,
+            total_latency_ms AS totalLatency
+       FROM daily_metrics
+       WHERE date = ?`,
+    [todayKey]
+  );
   const resolveAvg = (totalLatency, requests) => requests > 0 ? Math.round(totalLatency / requests) : 0;
-  const totalsRequests = totalsRow.requests ?? 0;
-  const totalsLatency = totalsRow.totalLatency ?? 0;
+  const totalsRequests = totalsRow?.requests ?? 0;
+  const totalsLatency = totalsRow?.totalLatency ?? 0;
   const todayRequests = todayRow?.requests ?? 0;
   const todayLatency = todayRow?.totalLatency ?? 0;
   return {
     totals: {
       requests: totalsRequests,
-      inputTokens: totalsRow.inputTokens ?? 0,
-      outputTokens: totalsRow.outputTokens ?? 0,
+      inputTokens: totalsRow?.inputTokens ?? 0,
+      outputTokens: totalsRow?.outputTokens ?? 0,
       avgLatencyMs: resolveAvg(totalsLatency, totalsRequests)
     },
     today: {
@@ -1767,35 +2038,44 @@ function getMetricsOverview() {
     }
   };
 }
-function getModelUsageMetrics(days = 7, limit = 10) {
-  const db2 = getDb();
+async function getModelUsageMetrics(days = 7, limit = 10) {
   const since = Date.now() - days * 24 * 60 * 60 * 1e3;
-  const rows = db2.prepare(
+  const rows = await getAll(
     `SELECT
-         model,
-         provider,
-         COUNT(*) AS requests,
-         COALESCE(SUM(input_tokens), 0) AS inputTokens,
-         COALESCE(SUM(output_tokens), 0) AS outputTokens,
-         COALESCE(SUM(latency_ms), 0) AS totalLatency
-       FROM request_logs
-       WHERE timestamp >= ?
-       GROUP BY provider, model
-       ORDER BY requests DESC
-       LIMIT ?`
-  ).all(since, limit);
+       model,
+       provider,
+       COUNT(*) AS requests,
+       COALESCE(SUM(input_tokens), 0) AS inputTokens,
+       COALESCE(SUM(output_tokens), 0) AS outputTokens,
+       COALESCE(SUM(latency_ms), 0) AS totalLatency,
+       AVG(CASE WHEN ttft_ms IS NULL THEN NULL ELSE ttft_ms END) AS avgTtftMs,
+       AVG(CASE WHEN tpot_ms IS NULL THEN NULL ELSE tpot_ms END) AS avgTpotMs
+     FROM request_logs
+     WHERE timestamp >= ?
+     GROUP BY provider, model
+     ORDER BY requests DESC
+     LIMIT ?`,
+    [since, limit]
+  );
+  const roundValue = (value, fractionDigits = 0) => value == null ? null : Number(value.toFixed(fractionDigits));
   return rows.map((row) => ({
     model: row.model,
     provider: row.provider,
     requests: row.requests ?? 0,
     inputTokens: row.inputTokens ?? 0,
     outputTokens: row.outputTokens ?? 0,
-    avgLatencyMs: row.requests ? Math.round((row.totalLatency ?? 0) / row.requests) : 0
+    avgLatencyMs: row.requests ? Math.round((row.totalLatency ?? 0) / row.requests) : 0,
+    avgTtftMs: roundValue(row.avgTtftMs, 0),
+    avgTpotMs: roundValue(row.avgTpotMs, 2)
   }));
 }
 
 // routes/admin.ts
 async function registerAdminRoutes(app) {
+  const mapLogRecord = (record) => ({
+    ...record,
+    stream: Boolean(record?.stream)
+  });
   app.get("/api/status", async () => {
     const config = getConfig();
     return {
@@ -1957,9 +2237,9 @@ async function registerAdminRoutes(app) {
     };
     const from = parseTime(query.from);
     const to = parseTime(query.to);
-    const { items, total } = queryLogs({ limit, offset, provider, model, status, from, to });
+    const { items, total } = await queryLogs({ limit, offset, provider, model, status, from, to });
     reply.header("x-total-count", String(total));
-    return { total, items };
+    return { total, items: items.map(mapLogRecord) };
   });
   app.get("/api/logs/:id", async (request, reply) => {
     const id = Number(request.params.id);
@@ -1967,25 +2247,30 @@ async function registerAdminRoutes(app) {
       reply.code(400);
       return { error: "Invalid id" };
     }
-    const record = getLogDetail(id);
+    const record = await getLogDetail(id);
     if (!record) {
       reply.code(404);
       return { error: "Not found" };
     }
-    const payload = getLogPayload(id);
-    return { ...record, payload };
+    const payload = await getLogPayload(id);
+    return { ...mapLogRecord(record), payload };
   });
   app.post("/api/logs/cleanup", async () => {
     const config = getConfig();
     const retentionDays = config.logRetentionDays ?? 30;
     const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
-    const deleted = cleanupLogsBefore(cutoff);
+    const deleted = await cleanupLogsBefore(cutoff);
     return { success: true, deleted };
   });
+  app.post("/api/logs/clear", async () => {
+    const { logs, metrics } = await clearAllLogs();
+    return { success: true, deleted: logs, metricsCleared: metrics };
+  });
   app.get("/api/db/info", async () => {
-    const db2 = getDb();
-    const pageCount = db2.pragma("page_count", { simple: true });
-    const pageSize = db2.pragma("page_size", { simple: true });
+    const pageCountRow = await getOne("PRAGMA page_count");
+    const pageSizeRow = await getOne("PRAGMA page_size");
+    const pageCount = pageCountRow?.page_count ?? 0;
+    const pageSize = pageSizeRow?.page_size ?? 0;
     return {
       pageCount,
       pageSize,
@@ -2021,7 +2306,7 @@ function startMaintenanceTimers() {
   scheduleCleanup();
 }
 function scheduleCleanup() {
-  const run = () => {
+  const run2 = () => {
     try {
       const retentionDays = getConfig().logRetentionDays ?? 30;
       const cutoff = Date.now() - retentionDays * DAY_MS;
@@ -2033,7 +2318,7 @@ function scheduleCleanup() {
       console.error("[maintenance] cleanup failed", err);
     }
   };
-  setInterval(run, DAY_MS);
+  setInterval(run2, DAY_MS);
 }
 
 // index.ts
@@ -2062,7 +2347,13 @@ function resolveWebDist() {
   return null;
 }
 async function createServer() {
-  const app = Fastify({ logger: true });
+  const config = cachedConfig2 ?? loadConfig();
+  const app = Fastify({
+    logger: {
+      level: config.logLevel ?? "info"
+    },
+    disableRequestLogging: config.requestLogging === false
+  });
   await app.register(fastifyCors, {
     origin: true,
     credentials: true