@chenpu17/cc-gw 0.2.1

package/src/server/dist/index.js

@@ -0,0 +1,2152 @@
+// index.ts
+import Fastify from "fastify";
+import fastifyCors from "@fastify/cors";
+import fastifyStatic from "@fastify/static";
+import fs3 from "fs";
+import path3 from "path";
+import process2 from "process";
+import { fileURLToPath } from "url";
+
+// config/manager.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { EventEmitter } from "events";
+var HOME_DIR = path.join(os.homedir(), ".cc-gw");
+var CONFIG_PATH = path.join(HOME_DIR, "config.json");
+var TypedEmitter = class extends EventEmitter {
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+  emitTyped(event, ...args) {
+    return super.emit(event, ...args);
+  }
+};
+var emitter = new TypedEmitter();
+var cachedConfig = null;
+function parseConfig(raw) {
+  const data = JSON.parse(raw);
+  if (typeof data.port !== "number") {
+    throw new Error("\u914D\u7F6E\u6587\u4EF6\u7F3A\u5C11\u6216\u9519\u8BEF\u7684 port \u5B57\u6BB5");
+  }
+  if (!Array.isArray(data.providers)) {
+    data.providers = [];
+  }
+  if (!data.defaults) {
+    data.defaults = {
+      completion: null,
+      reasoning: null,
+      background: null,
+      longContextThreshold: 6e4
+    };
+  } else {
+    data.defaults.longContextThreshold ??= 6e4;
+  }
+  if (typeof data.logRetentionDays !== "number") {
+    data.logRetentionDays = 30;
+  }
+  if (typeof data.storePayloads !== "boolean") {
+    data.storePayloads = true;
+  }
+  if (!data.modelRoutes || typeof data.modelRoutes !== "object") {
+    data.modelRoutes = {};
+  } else {
+    const sanitized = {};
+    for (const [key, value] of Object.entries(data.modelRoutes)) {
+      if (typeof value !== "string")
+        continue;
+      const trimmedKey = key.trim();
+      const trimmedValue = value.trim();
+      if (!trimmedKey || !trimmedValue)
+        continue;
+      sanitized[trimmedKey] = trimmedValue;
+    }
+    data.modelRoutes = sanitized;
+  }
+  return data;
+}
+function loadConfig() {
+  if (!fs.existsSync(CONFIG_PATH)) {
+    throw new Error(`\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728: ${CONFIG_PATH}`);
+  }
+  const raw = fs.readFileSync(CONFIG_PATH, "utf-8");
+  cachedConfig = parseConfig(raw);
+  return cachedConfig;
+}
+function getConfig() {
+  if (cachedConfig)
+    return cachedConfig;
+  return loadConfig();
+}
+function updateConfig(next) {
+  fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(next, null, 2), "utf-8");
+  cachedConfig = next;
+  emitter.emitTyped("change", cachedConfig);
+}
+function onConfigChange(listener) {
+  emitter.on("change", listener);
+  if (cachedConfig)
+    listener(cachedConfig);
+  return () => emitter.off("change", listener);
+}
+
+// protocol/normalize.ts
+function extractText(content) {
+  if (content == null)
+    return "";
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    return content.map((item) => {
+      if (typeof item === "string")
+        return item;
+      if (item && typeof item === "object") {
+        if (item.type === "text" && item.text)
+          return item.text;
+        if (item.content)
+          return extractText(item.content);
+      }
+      return "";
+    }).filter(Boolean).join("\n");
+  }
+  if (typeof content === "object") {
+    if (content.text)
+      return content.text;
+    if (content.content)
+      return extractText(content.content);
+  }
+  return "";
+}
+function normalizeSystem(messages, systemField) {
+  const systemParts = [];
+  if (Array.isArray(systemField)) {
+    systemParts.push(...systemField.map((item) => extractText(item)));
+  } else if (typeof systemField === "string") {
+    systemParts.push(systemField);
+  } else if (systemField) {
+    systemParts.push(extractText(systemField));
+  }
+  const remaining = [];
+  for (const msg of messages) {
+    if (msg.role === "system" || msg.role === "developer") {
+      const text = extractText(msg.content);
+      if (text)
+        systemParts.push(text);
+      continue;
+    }
+    remaining.push(msg);
+  }
+  const system = systemParts.filter((part) => part && part.trim().length > 0).join("\n\n") || null;
+  return { system, remaining };
+}
+function normalizeClaudePayload(payload) {
+  const stream = Boolean(payload.stream);
+  const thinking = Boolean(payload.thinking);
+  const messages = Array.isArray(payload.messages) ? payload.messages : payload.messages ? [payload.messages] : [];
+  const { system, remaining } = normalizeSystem(messages, payload.system);
+  const normalizedMessages = remaining.map((msg) => {
+    if (msg.role === "user") {
+      if (Array.isArray(msg.content)) {
+        const textParts = [];
+        const toolResults = [];
+        for (const block of msg.content) {
+          if (block.type === "text" && block.text) {
+            textParts.push(block.text);
+          } else if (block.type === "tool_result") {
+            toolResults.push({
+              id: block.tool_use_id || block.id || "tool_result",
+              name: block.name,
+              content: block.content ?? block.text ?? null,
+              cacheControl: block.cache_control
+            });
+          }
+        }
+        return {
+          role: "user",
+          text: textParts.join("\n"),
+          toolResults
+        };
+      }
+      return {
+        role: "user",
+        text: extractText(msg.content)
+      };
+    }
+    if (msg.role === "assistant") {
+      const toolCalls = [];
+      let text = "";
+      if (Array.isArray(msg.content)) {
+        const textParts = [];
+        for (const block of msg.content) {
+          if (block.type === "text" && block.text) {
+            textParts.push(block.text);
+          } else if (block.type === "tool_use") {
+            toolCalls.push({
+              id: block.id || `call_${Math.random().toString(36).slice(2)}`,
+              name: block.name,
+              arguments: block.input,
+              cacheControl: block.cache_control
+            });
+          }
+        }
+        text = textParts.join("\n");
+      } else if (typeof msg.content === "string") {
+        text = msg.content;
+      }
+      return {
+        role: "assistant",
+        text,
+        toolCalls
+      };
+    }
+    return {
+      role: "user",
+      text: extractText(msg.content)
+    };
+  });
+  return {
+    original: payload,
+    system,
+    messages: normalizedMessages,
+    tools: Array.isArray(payload.tools) ? payload.tools : [],
+    stream,
+    thinking
+  };
+}
+
+// protocol/tokenizer.ts
+import { encoding_for_model } from "tiktoken";
+function getEncoder(model) {
+  try {
+    return encoding_for_model(model);
+  } catch {
+    return encoding_for_model("gpt-3.5-turbo");
+  }
+}
+function estimateTextTokens(text, model) {
+  if (!text)
+    return 0;
+  try {
+    const encoder2 = getEncoder(model);
+    return encoder2.encode(text).length;
+  } catch {
+    return Math.ceil(text.length / 4);
+  }
+}
+function estimateTokens(payload, model) {
+  try {
+    const encoder2 = getEncoder(model);
+    let total = 0;
+    if (payload.system) {
+      total += encoder2.encode(payload.system).length;
+    }
+    for (const message of payload.messages) {
+      if (message.text) {
+        total += encoder2.encode(message.text).length;
+      }
+      if (message.toolCalls) {
+        for (const call of message.toolCalls) {
+          total += encoder2.encode(JSON.stringify(call.arguments ?? {})).length;
+        }
+      }
+      if (message.toolResults) {
+        for (const result of message.toolResults) {
+          total += encoder2.encode(JSON.stringify(result.content ?? "")).length;
+        }
+      }
+    }
+    return total;
+  } catch {
+    const text = [payload.system ?? "", ...payload.messages.map((m) => m.text ?? "")].join("\n");
+    return Math.ceil(text.length / 4);
+  }
+}
+
+// router/index.ts
+function resolveByIdentifier(identifier, providers) {
+  if (!identifier)
+    return null;
+  if (identifier.includes(":")) {
+    const [providerId, modelId] = identifier.split(":", 2);
+    const provider = providers.find((p) => p.id === providerId);
+    if (provider && (provider.defaultModel === modelId || provider.models?.some((m) => m.id === modelId))) {
+      return { providerId, modelId, provider, tokenEstimate: 0 };
+    }
+  } else {
+    for (const provider of providers) {
+      if (provider.defaultModel === identifier || provider.models?.some((m) => m.id === identifier)) {
+        return { providerId: provider.id, modelId: identifier, provider, tokenEstimate: 0 };
+      }
+    }
+  }
+  return null;
+}
+function resolveRoute(ctx) {
+  const config = getConfig();
+  const providers = config.providers;
+  if (!providers.length) {
+    throw new Error("\u672A\u914D\u7F6E\u4EFB\u4F55\u6A21\u578B\u63D0\u4F9B\u5546\uFF0C\u8BF7\u5148\u5728 Web UI \u4E2D\u6DFB\u52A0 Provider\u3002");
+  }
+  const requestedModel = ctx.requestedModel?.trim();
+  const mappedIdentifier = requestedModel ? config.modelRoutes?.[requestedModel] ?? null : null;
+  const fallbackModelId = providers[0].defaultModel ?? providers[0].models?.[0]?.id ?? "gpt-4o";
+  const tokenEstimate = estimateTokens(
+    ctx.payload,
+    mappedIdentifier ?? requestedModel ?? fallbackModelId
+  );
+  const strategy = ctx.payload;
+  const defaults = config.defaults;
+  if (mappedIdentifier) {
+    const mapped = resolveByIdentifier(mappedIdentifier, providers);
+    if (mapped) {
+      return { ...mapped, tokenEstimate };
+    }
+    console.warn(`modelRoutes \u6620\u5C04\u76EE\u6807\u65E0\u6548: ${mappedIdentifier}`);
+  }
+  const fromRequest = resolveByIdentifier(requestedModel, providers);
+  if (fromRequest) {
+    return { ...fromRequest, tokenEstimate };
+  }
+  if (strategy.thinking && defaults.reasoning) {
+    const target = resolveByIdentifier(defaults.reasoning, providers);
+    if (target)
+      return { ...target, tokenEstimate };
+  }
+  if (tokenEstimate > (defaults.longContextThreshold ?? 6e4) && defaults.background) {
+    const target = resolveByIdentifier(defaults.background, providers);
+    if (target)
+      return { ...target, tokenEstimate };
+  }
+  if (defaults.completion) {
+    const target = resolveByIdentifier(defaults.completion, providers);
+    if (target)
+      return { ...target, tokenEstimate };
+  }
+  const firstProvider = providers[0];
+  const modelId = firstProvider.defaultModel || firstProvider.models?.[0]?.id;
+  if (!modelId) {
+    throw new Error(`Provider ${firstProvider.id} \u672A\u914D\u7F6E\u4EFB\u4F55\u6A21\u578B`);
+  }
+  return {
+    providerId: firstProvider.id,
+    modelId,
+    provider: firstProvider,
+    tokenEstimate
+  };
+}
+
+// protocol/toProvider.ts
+function buildMessages(payload) {
+  const messages = [];
+  if (payload.system) {
+    messages.push({ role: "system", content: payload.system });
+  }
+  for (const message of payload.messages) {
+    if (message.role === "user") {
+      if (message.toolResults?.length) {
+        for (const tool of message.toolResults) {
+          const serialized = typeof tool.content === "string" ? tool.content : JSON.stringify(tool.content ?? "");
+          messages.push({
+            role: "tool",
+            tool_call_id: tool.id,
+            name: tool.name ?? tool.id,
+            content: serialized ?? "",
+            cache_control: tool.cacheControl
+          });
+        }
+      }
+      const userContent = message.text ?? "";
+      const hasUserText = userContent.trim().length > 0;
+      if (hasUserText || !message.toolResults?.length) {
+        messages.push({ role: "user", content: hasUserText ? userContent : "" });
+      }
+    } else if (message.role === "assistant") {
+      const openAiMsg = {
+        role: "assistant",
+        content: message.text ?? ""
+      };
+      if (message.toolCalls?.length) {
+        openAiMsg.tool_calls = message.toolCalls.map((call) => ({
+          id: call.id,
+          type: "function",
+          function: {
+            name: call.name,
+            arguments: typeof call.arguments === "string" ? call.arguments : JSON.stringify(call.arguments ?? {})
+          },
+          cache_control: call.cacheControl
+        }));
+        if (!openAiMsg.content) {
+          openAiMsg.content = null;
+        }
+      }
+      messages.push(openAiMsg);
+    }
+  }
+  return messages;
+}
+function buildProviderBody(payload, options = {}) {
+  const body = {
+    messages: buildMessages(payload)
+  };
+  if (options.maxTokens) {
+    if (payload.thinking) {
+      body.max_completion_tokens = options.maxTokens;
+    } else {
+      body.max_tokens = options.maxTokens;
+    }
+  }
+  if (typeof options.temperature === "number") {
+    body.temperature = options.temperature;
+  }
+  const tools = options.overrideTools ?? payload.tools;
+  if (tools && tools.length > 0) {
+    body.tools = tools.map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.input_schema ?? tool.parameters ?? {}
+      }
+    }));
+  }
+  if (options.toolChoice) {
+    body.tool_choice = options.toolChoice;
+  }
+  const passthroughKeys = [
+    "cache_control",
+    "metadata",
+    "response_format",
+    "parallel_tool_calls",
+    "frequency_penalty",
+    "presence_penalty",
+    "logit_bias",
+    "top_p",
+    "top_k",
+    "stop",
+    "stop_sequences",
+    "user",
+    "seed",
+    "n",
+    "options"
+  ];
+  const original = payload.original ?? {};
+  for (const key of passthroughKeys) {
+    if (Object.prototype.hasOwnProperty.call(original, key)) {
+      const value = original[key];
+      if (value !== void 0) {
+        ;
+        body[key] = value;
+      }
+    }
+  }
+  return body;
+}
+function buildAnthropicContentFromText(text) {
+  if (!text || text.length === 0) {
+    return [];
+  }
+  return [
+    {
+      type: "text",
+      text
+    }
+  ];
+}
+function buildAnthropicBody(payload, options = {}) {
+  const messages = [];
+  for (const message of payload.messages) {
+    const blocks = [];
+    if (message.text) {
+      blocks.push(...buildAnthropicContentFromText(message.text));
+    }
+    if (message.role === "user" && message.toolResults?.length) {
+      for (const result of message.toolResults) {
+        const content = typeof result.content === "string" ? [{ type: "text", text: result.content }] : [{ type: "text", text: JSON.stringify(result.content ?? "") }];
+        blocks.push({
+          type: "tool_result",
+          tool_use_id: result.id,
+          content,
+          cache_control: result.cacheControl
+        });
+      }
+    }
+    if (message.role === "assistant" && message.toolCalls?.length) {
+      for (const call of message.toolCalls) {
+        blocks.push({
+          type: "tool_use",
+          id: call.id,
+          name: call.name,
+          input: call.arguments ?? {},
+          cache_control: call.cacheControl
+        });
+      }
+    }
+    if (message.role === "assistant" || message.role === "user") {
+      if (blocks.length === 0) {
+        blocks.push({ type: "text", text: "" });
+      }
+      messages.push({
+        role: message.role,
+        content: blocks
+      });
+    }
+  }
+  const body = {
+    system: payload.system ?? void 0,
+    messages
+  };
+  if (options.maxTokens) {
+    body.max_tokens = options.maxTokens;
+  }
+  if (typeof options.temperature === "number") {
+    body.temperature = options.temperature;
+  }
+  const tools = options.overrideTools ?? payload.tools;
+  if (tools && tools.length > 0) {
+    body.tools = tools.map((tool) => ({
+      type: "tool",
+      name: tool.name,
+      description: tool.description,
+      input_schema: tool.input_schema ?? tool.parameters ?? {}
+    }));
+  }
+  if (options.toolChoice) {
+    body.tool_choice = options.toolChoice;
+  }
+  return body;
+}
+
+// providers/openai.ts
+import { fetch } from "undici";
+import { ReadableStream } from "stream/web";
+var encoder = new TextEncoder();
+function createJsonStream(payload) {
+  const text = typeof payload === "string" ? payload : JSON.stringify(payload);
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(encoder.encode(text));
+      controller.close();
+    }
+  });
+}
+function resolveEndpoint(config, options) {
+  if (options?.endpoint)
+    return options.endpoint;
+  const base = config.baseUrl.replace(/\/$/, "");
+  const defaultPath = options?.defaultPath ?? "v1/chat/completions";
+  if (base.endsWith("/chat/completions"))
+    return base;
+  let pathSegment = defaultPath;
+  const versionMatch = base.match(/\/v(\d+)$/);
+  if (versionMatch && defaultPath.startsWith("v1/")) {
+    pathSegment = defaultPath.slice(3);
+  }
+  if (pathSegment.startsWith("/")) {
+    pathSegment = pathSegment.slice(1);
+  }
+  return `${base}/${pathSegment}`;
+}
+function createOpenAIConnector(config, options) {
+  const url = resolveEndpoint(config, options);
+  const shouldLogEndpoint = process.env.CC_GW_DEBUG_ENDPOINTS === "1";
+  return {
+    id: config.id,
+    async send(request) {
+      const headers = {
+        "Content-Type": "application/json",
+        ...config.extraHeaders,
+        ...request.headers
+      };
+      if (config.apiKey) {
+        headers["Authorization"] = `Bearer ${config.apiKey}`;
+      }
+      const body = {
+        ...request.body,
+        model: request.model,
+        stream: request.stream ?? false
+      };
+      const payload = options?.mutateBody ? options.mutateBody(body) : body;
+      if (shouldLogEndpoint) {
+        console.info(`[cc-gw] provider=${config.id} endpoint=${url}`);
+      }
+      const res = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload)
+      });
+      if (shouldLogEndpoint) {
+        console.info(`[cc-gw] provider=${config.id} status=${res.status}`);
+      }
+      if (res.status >= 400 && options?.mapErrorBody) {
+        let raw = null;
+        try {
+          raw = await res.json();
+        } catch {
+          raw = await res.text();
+        }
+        if (shouldLogEndpoint) {
+          console.warn(`[cc-gw] provider=${config.id} error_body=${typeof raw === "string" ? raw : JSON.stringify(raw)}`);
+        }
+        const mapped = options.mapErrorBody(raw);
+        return {
+          status: res.status,
+          headers: res.headers,
+          body: createJsonStream(mapped)
+        };
+      }
+      return {
+        status: res.status,
+        headers: res.headers,
+        body: res.body
+      };
+    }
+  };
+}
+
+// providers/kimi.ts
+var codeMessageMap = {
+  invalid_api_key: "Kimi API Key \u65E0\u6548\uFF0C\u8BF7\u786E\u8BA4\u5728\u63A7\u5236\u53F0\u590D\u5236\u7684\u503C\u662F\u5426\u6B63\u786E",
+  permission_denied: "Kimi API \u6743\u9650\u4E0D\u8DB3\u6216\u8D26\u53F7\u72B6\u6001\u5F02\u5E38",
+  insufficient_quota: "Kimi \u914D\u989D\u4E0D\u8DB3\uFF0C\u8BF7\u524D\u5F80\u6708\u4E4B\u6697\u9762\u63A7\u5236\u53F0\u5145\u503C",
+  rate_limit_exceeded: "Kimi \u8BF7\u6C42\u8FC7\u4E8E\u9891\u7E41\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5"
+};
+function mapKimiError(payload) {
+  if (typeof payload === "string") {
+    try {
+      return mapKimiError(JSON.parse(payload));
+    } catch {
+      return { error: { message: payload, code: "unknown_error" } };
+    }
+  }
+  const data = payload;
+  const code = data?.error?.code ?? data?.error?.type ?? "unknown_error";
+  const message = codeMessageMap[code] ?? data?.error?.message ?? "Kimi \u8BF7\u6C42\u5931\u8D25";
+  return {
+    error: {
+      code,
+      message
+    }
+  };
+}
+function createKimiConnector(config) {
+  const base = config.baseUrl.replace(/\/$/, "");
+  const endpointBase = base.endsWith("/v1") ? base.slice(0, -3) : base;
+  const endpoint = `${endpointBase}/v1/chat/completions`;
+  if (process.env.CC_GW_DEBUG_ENDPOINTS === "1") {
+    console.info(`[cc-gw] kimi connector base=${config.baseUrl} resolved=${endpoint}`);
+  }
+  return createOpenAIConnector(config, {
+    endpoint,
+    mapErrorBody: mapKimiError
+  });
+}
+
+// providers/deepseek.ts
+var codeMessageMap2 = {
+  authentication_error: "DeepSeek API Key \u65E0\u6548\u6216\u672A\u914D\u7F6E",
+  permission_denied: "DeepSeek API Key \u6743\u9650\u4E0D\u8DB3\uFF0C\u8BF7\u68C0\u67E5\u8BA2\u9605\u8BA1\u5212",
+  rate_limit_exceeded: "DeepSeek \u8BF7\u6C42\u9891\u7387\u5DF2\u8FBE\u4E0A\u9650\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5",
+  insufficient_quota: "DeepSeek \u8D26\u6237\u4F59\u989D\u4E0D\u8DB3\uFF0C\u8BF7\u5145\u503C\u540E\u7EE7\u7EED\u4F7F\u7528"
+};
+function mapDeepSeekError(payload) {
+  if (typeof payload === "string") {
+    try {
+      return mapDeepSeekError(JSON.parse(payload));
+    } catch {
+      return { error: { message: payload, code: "unknown_error" } };
+    }
+  }
+  const data = payload;
+  const code = data?.error?.code ?? data?.error?.type ?? "unknown_error";
+  const mappedMessage = codeMessageMap2[code] ?? data?.error?.message ?? "DeepSeek \u8BF7\u6C42\u5931\u8D25";
+  return {
+    error: {
+      code,
+      message: mappedMessage
+    }
+  };
+}
+function createDeepSeekConnector(config) {
+  return createOpenAIConnector(config, {
+    defaultPath: "v1/chat/completions",
+    mapErrorBody: mapDeepSeekError
+  });
+}
+
+// providers/anthropic.ts
+import { fetch as fetch2 } from "undici";
+var DEFAULT_VERSION = "2023-06-01";
+function createAnthropicConnector(config) {
+  const baseUrl = config.baseUrl.replace(/\/$/, "");
+  return {
+    id: config.id,
+    async send(request) {
+      const headers = {
+        "Content-Type": "application/json",
+        "anthropic-version": DEFAULT_VERSION,
+        ...config.extraHeaders,
+        ...request.headers
+      };
+      delete headers.Authorization;
+      if (config.apiKey) {
+        headers["x-api-key"] = config.apiKey;
+      }
+      if (!headers["anthropic-version"]) {
+        headers["anthropic-version"] = DEFAULT_VERSION;
+      }
+      const payload = {
+        ...request.body,
+        model: request.model,
+        stream: request.stream ?? false
+      };
+      const response = await fetch2(`${baseUrl}/messages`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(payload)
+      });
+      return {
+        status: response.status,
+        headers: response.headers,
+        body: response.body
+      };
+    }
+  };
+}
+
+// providers/registry.ts
+var connectors = /* @__PURE__ */ new Map();
+function buildConnector(config) {
+  switch (config.type) {
+    case "deepseek":
+      return createDeepSeekConnector(config);
+    case "kimi":
+      return createKimiConnector(config);
+    case "anthropic":
+      return createAnthropicConnector(config);
+    case "openai":
+    case "custom":
+    default:
+      return createOpenAIConnector(config);
+  }
+}
+function rebuildConnectors() {
+  const config = getConfig();
+  connectors = new Map(config.providers.map((provider) => [provider.id, buildConnector(provider)]));
+}
+rebuildConnectors();
+onConfigChange(() => rebuildConnectors());
+function getConnector(providerId) {
+  const connector = connectors.get(providerId);
+  if (!connector) {
+    throw new Error(`\u672A\u627E\u5230 provider: ${providerId}`);
+  }
+  return connector;
+}
+
+// logging/logger.ts
+import { brotliCompressSync, brotliDecompressSync, constants as zlibConstants } from "zlib";
+
+// storage/index.ts
+import fs2 from "fs";
+import os2 from "os";
+import path2 from "path";
+import Database from "better-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 (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      timestamp INTEGER NOT NULL,
+      session_id TEXT,
+      provider TEXT NOT NULL,
+      model TEXT NOT NULL,
+      client_model TEXT,
+      latency_ms INTEGER,
+      status_code INTEGER,
+      input_tokens INTEGER,
+      output_tokens INTEGER,
+      cached_tokens INTEGER,
+      ttft_ms INTEGER,
+      tpot_ms REAL,
+      error TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS request_payloads (
+      request_id INTEGER PRIMARY KEY,
+      prompt TEXT,
+      response TEXT,
+      FOREIGN KEY(request_id) REFERENCES request_logs(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS daily_metrics (
+      date TEXT PRIMARY KEY,
+      request_count INTEGER DEFAULT 0,
+      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;
+}
+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");
+  }
+}
+
+// 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
+  }
+};
+function compressPayload(value) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  if (value.length === 0) {
+    return Buffer.alloc(0);
+  }
+  return brotliCompressSync(Buffer.from(value, "utf8"), BROTLI_OPTIONS);
+}
+function decompressPayload(value) {
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Buffer.isBuffer(value)) {
+    if (value.length === 0) {
+      return "";
+    }
+    try {
+      const decompressed = brotliDecompressSync(value);
+      return decompressed.toString("utf8");
+    } catch {
+      return value.toString("utf8");
+    }
+  }
+  return null;
+}
+function updateLogTokens(requestId, values) {
+  const db2 = getDb();
+  const setters = ["input_tokens = ?", "output_tokens = ?", "cached_tokens = ?"];
+  const params = [
+    values.inputTokens,
+    values.outputTokens,
+    values.cachedTokens ?? null
+  ];
+  if (values.ttftMs !== void 0) {
+    setters.push("ttft_ms = ?");
+    params.push(values.ttftMs ?? null);
+  }
+  if (values.tpotMs !== void 0) {
+    setters.push("tpot_ms = ?");
+    params.push(values.tpotMs ?? null);
+  }
+  db2.prepare(`UPDATE request_logs SET ${setters.join(", ")} WHERE id = ?`).run(...params, requestId);
+}
+function finalizeLog(requestId, info) {
+  const db2 = getDb();
+  const setters = [];
+  const values = [];
+  if (info.latencyMs !== void 0) {
+    setters.push("latency_ms = ?");
+    values.push(info.latencyMs);
+  }
+  if (info.statusCode !== void 0) {
+    setters.push("status_code = ?");
+    values.push(info.statusCode ?? null);
+  }
+  if (info.error !== void 0) {
+    setters.push("error = ?");
+    values.push(info.error ?? null);
+  }
+  if (info.clientModel !== void 0) {
+    setters.push("client_model = ?");
+    values.push(info.clientModel ?? null);
+  }
+  if (setters.length === 0)
+    return;
+  const stmt = db2.prepare(`UPDATE request_logs SET ${setters.join(", ")} WHERE id = ?`);
+  stmt.run(...values, requestId);
+}
+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
+  );
+}
+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
+  });
+}
+
+// metrics/activity.ts
+var activeRequests = 0;
+function incrementActiveRequests() {
+  activeRequests += 1;
+}
+function decrementActiveRequests() {
+  if (activeRequests > 0) {
+    activeRequests -= 1;
+  }
+}
+function getActiveRequestCount() {
+  return activeRequests;
+}
+
+// routes/messages.ts
+function mapStopReason(reason) {
+  switch (reason) {
+    case "stop":
+      return "end_turn";
+    case "tool_calls":
+      return "tool_use";
+    case "length":
+      return "max_tokens";
+    default:
+      return reason ?? null;
+  }
+}
+var roundTwoDecimals = (value) => Math.round(value * 100) / 100;
+function computeTpot(totalLatencyMs, outputTokens, options) {
+  if (!Number.isFinite(outputTokens) || outputTokens <= 0) {
+    return null;
+  }
+  const streaming = options?.streaming ?? false;
+  const ttftMs = options?.ttftMs ?? null;
+  if (streaming && (ttftMs === null || ttftMs === void 0)) {
+    return null;
+  }
+  const effectiveLatency = streaming && ttftMs != null ? Math.max(totalLatencyMs - ttftMs, 0) : totalLatencyMs;
+  const raw = effectiveLatency / outputTokens;
+  return Number.isFinite(raw) ? roundTwoDecimals(raw) : null;
+}
+function resolveCachedTokens(usage) {
+  if (!usage || typeof usage !== "object") {
+    return null;
+  }
+  if (typeof usage.cached_tokens === "number") {
+    return usage.cached_tokens;
+  }
+  const promptDetails = usage.prompt_tokens_details;
+  if (promptDetails && typeof promptDetails.cached_tokens === "number") {
+    return promptDetails.cached_tokens;
+  }
+  return null;
+}
+function buildClaudeResponse(openAI, model) {
+  const choice = openAI.choices?.[0];
+  const message = choice?.message ?? {};
+  const contentBlocks = [];
+  if (typeof message.content === "string" && message.content.length > 0) {
+    contentBlocks.push({ type: "text", text: message.content });
+  }
+  if (Array.isArray(message.tool_calls)) {
+    for (const call of message.tool_calls) {
+      contentBlocks.push({
+        type: "tool_use",
+        id: call.id || `tool_${Math.random().toString(36).slice(2)}`,
+        name: call.function?.name,
+        input: (() => {
+          try {
+            return call.function?.arguments ? JSON.parse(call.function.arguments) : {};
+          } catch {
+            return {};
+          }
+        })()
+      });
+    }
+  }
+  return {
+    id: openAI.id ? openAI.id.replace("chatcmpl", "msg") : `msg_${Math.random().toString(36).slice(2)}`,
+    type: "message",
+    role: "assistant",
+    model,
+    content: contentBlocks,
+    stop_reason: mapStopReason(choice?.finish_reason),
+    stop_sequence: null,
+    usage: {
+      input_tokens: openAI.usage?.prompt_tokens ?? 0,
+      output_tokens: openAI.usage?.completion_tokens ?? 0
+    }
+  };
+}
+async function registerMessagesRoute(app) {
+  app.post("/v1/messages", async (request, reply) => {
+    const payload = request.body;
+    if (!payload || typeof payload !== "object") {
+      reply.code(400);
+      return { error: "Invalid request body" };
+    }
+    const normalized = normalizeClaudePayload(payload);
+    const requestedModel = typeof payload.model === "string" ? payload.model : void 0;
+    const target = resolveRoute({
+      payload: normalized,
+      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 connector = getConnector(target.providerId);
+    const requestStart = Date.now();
+    const storePayloads = getConfig().storePayloads !== false;
+    const logId = recordLog({
+      timestamp: requestStart,
+      provider: target.providerId,
+      model: target.modelId,
+      clientModel: requestedModel,
+      sessionId: payload.metadata?.user_id
+    });
+    incrementActiveRequests();
+    if (storePayloads) {
+      upsertLogPayload(logId, {
+        prompt: (() => {
+          try {
+            return JSON.stringify(payload);
+          } catch {
+            return null;
+          }
+        })()
+      });
+    }
+    let finalized = false;
+    const finalize = (statusCode, error) => {
+      if (finalized)
+        return;
+      finalizeLog(logId, {
+        latencyMs: Date.now() - requestStart,
+        statusCode,
+        error,
+        clientModel: requestedModel ?? null
+      });
+      finalized = true;
+    };
+    const logUsage = (stage, usage) => {
+      request.log.info(
+        {
+          event: "usage.metrics",
+          stage,
+          provider: target.providerId,
+          model: target.modelId,
+          stream: normalized.stream,
+          tokens: usage
+        },
+        "upstream usage summary"
+      );
+      console.info("[cc-gw][usage]", stage, {
+        provider: target.providerId,
+        model: target.modelId,
+        stream: normalized.stream,
+        tokens: usage
+      });
+    };
+    try {
+      const upstream = await connector.send({
+        model: target.modelId,
+        body: providerBody,
+        stream: normalized.stream
+      });
+      if (upstream.status >= 400) {
+        reply.code(upstream.status);
+        const bodyText = upstream.body ? await new Response(upstream.body).text() : "";
+        const errorText = bodyText || "Upstream provider error";
+        if (storePayloads) {
+          upsertLogPayload(logId, { response: bodyText || null });
+        }
+        finalize(upstream.status, errorText);
+        return { error: errorText };
+      }
+      if (!normalized.stream) {
+        const json = await new Response(upstream.body).json();
+        if (providerType === "anthropic") {
+          let inputTokens2 = json.usage?.input_tokens ?? 0;
+          let outputTokens2 = json.usage?.output_tokens ?? 0;
+          const cachedTokens2 = resolveCachedTokens(json.usage);
+          if (!inputTokens2) {
+            inputTokens2 = target.tokenEstimate || estimateTokens(normalized, target.modelId);
+          }
+          if (!outputTokens2) {
+            const textBlocks = Array.isArray(json.content) ? json.content.filter((block) => block?.type === "text").map((block) => block.text ?? "").join("\n") : "";
+            outputTokens2 = estimateTextTokens(textBlocks, target.modelId);
+          }
+          logUsage("non_stream.anthropic", {
+            input: inputTokens2,
+            output: outputTokens2,
+            cached: cachedTokens2
+          });
+          const latencyMs2 = Date.now() - requestStart;
+          updateLogTokens(logId, {
+            inputTokens: inputTokens2,
+            outputTokens: outputTokens2,
+            cachedTokens: cachedTokens2,
+            ttftMs: latencyMs2,
+            tpotMs: computeTpot(latencyMs2, outputTokens2, { streaming: false })
+          });
+          updateMetrics((/* @__PURE__ */ new Date()).toISOString().slice(0, 10), {
+            requests: 1,
+            inputTokens: inputTokens2,
+            outputTokens: outputTokens2,
+            latencyMs: latencyMs2
+          });
+          if (storePayloads) {
+            upsertLogPayload(logId, {
+              response: (() => {
+                try {
+                  return JSON.stringify(json);
+                } catch {
+                  return null;
+                }
+              })()
+            });
+          }
+          finalize(200, null);
+          reply.header("content-type", "application/json");
+          return json;
+        }
+        const claudeResponse = buildClaudeResponse(json, target.modelId);
+        let inputTokens = json.usage?.prompt_tokens ?? 0;
+        let outputTokens = json.usage?.completion_tokens ?? 0;
+        const cachedTokens = resolveCachedTokens(json.usage);
+        if (!inputTokens) {
+          inputTokens = target.tokenEstimate || estimateTokens(normalized, target.modelId);
+        }
+        if (!outputTokens) {
+          const text = claudeResponse.content.filter((block) => block?.type === "text").map((block) => block.text ?? "").join("\n");
+          outputTokens = estimateTextTokens(text, target.modelId);
+        }
+        logUsage("non_stream.openai", {
+          input: inputTokens,
+          output: outputTokens,
+          cached: cachedTokens
+        });
+        const latencyMs = Date.now() - requestStart;
+        updateLogTokens(logId, {
+          inputTokens,
+          outputTokens,
+          cachedTokens,
+          ttftMs: latencyMs,
+          tpotMs: computeTpot(latencyMs, outputTokens, { streaming: false })
+        });
+        updateMetrics((/* @__PURE__ */ new Date()).toISOString().slice(0, 10), {
+          requests: 1,
+          inputTokens,
+          outputTokens,
+          latencyMs
+        });
+        if (storePayloads) {
+          upsertLogPayload(logId, {
+            response: (() => {
+              try {
+                return JSON.stringify(claudeResponse);
+              } catch {
+                return null;
+              }
+            })()
+          });
+        }
+        finalize(200, null);
+        reply.header("content-type", "application/json");
+        return claudeResponse;
+      }
+      if (!upstream.body) {
+        reply.code(500);
+        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.raw.writeHead(200);
+      if (providerType === "anthropic") {
+        const reader2 = upstream.body.getReader();
+        const decoder2 = new TextDecoder();
+        let buffer2 = "";
+        let currentEvent = null;
+        let usagePrompt2 = 0;
+        let usageCompletion2 = 0;
+        let usageCached2 = null;
+        let accumulatedContent2 = "";
+        while (true) {
+          const { value, done } = await reader2.read();
+          if (done)
+            break;
+          if (!value)
+            continue;
+          const chunk = decoder2.decode(value, { stream: true });
+          buffer2 += chunk;
+          let newlineIndex = buffer2.indexOf("\n");
+          while (newlineIndex !== -1) {
+            const line = buffer2.slice(0, newlineIndex + 1);
+            buffer2 = buffer2.slice(newlineIndex + 1);
+            const trimmed = line.trim();
+            if (trimmed.startsWith("event:")) {
+              currentEvent = trimmed.slice(6).trim();
+            } else if (trimmed.startsWith("data:")) {
+              if (currentEvent === "message_delta" || currentEvent === "message_stop") {
+                try {
+                  const data = JSON.parse(trimmed.slice(5).trim());
+                  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 deltaText = data?.delta?.text;
+                  if (typeof deltaText === "string") {
+                    accumulatedContent2 += deltaText;
+                  }
+                } catch (error) {
+                  request.log.warn({ error }, "Failed to parse Anthropic SSE data");
+                }
+              }
+            }
+            reply.raw.write(line);
+            newlineIndex = buffer2.indexOf("\n");
+          }
+        }
+        if (buffer2.length > 0) {
+          reply.raw.write(buffer2);
+        }
+        reply.raw.end();
+        if (!usagePrompt2) {
+          usagePrompt2 = target.tokenEstimate || estimateTokens(normalized, target.modelId);
+        }
+        if (!usageCompletion2) {
+          usageCompletion2 = accumulatedContent2 ? estimateTextTokens(accumulatedContent2, target.modelId) : estimateTextTokens("", target.modelId);
+        }
+        const totalLatencyMs = Date.now() - requestStart;
+        const ttftMs = firstTokenAt ? firstTokenAt - requestStart : null;
+        logUsage("stream.anthropic.final", {
+          input: usagePrompt2,
+          output: usageCompletion2,
+          cached: usageCached2
+        });
+        updateLogTokens(logId, {
+          inputTokens: usagePrompt2,
+          outputTokens: usageCompletion2,
+          cachedTokens: usageCached2,
+          ttftMs,
+          tpotMs: computeTpot(totalLatencyMs, usageCompletion2, {
+            streaming: true,
+            ttftMs
+          })
+        });
+        updateMetrics((/* @__PURE__ */ new Date()).toISOString().slice(0, 10), {
+          requests: 1,
+          inputTokens: usagePrompt2,
+          outputTokens: usageCompletion2,
+          latencyMs: totalLatencyMs
+        });
+        if (storePayloads) {
+          upsertLogPayload(logId, {
+            response: (() => {
+              try {
+                return JSON.stringify({
+                  content: accumulatedContent2,
+                  usage: {
+                    input: usagePrompt2,
+                    output: usageCompletion2,
+                    cached: usageCached2
+                  }
+                });
+              } catch {
+                return accumulatedContent2;
+              }
+            })()
+          });
+        }
+        finalize(200, null);
+        return reply;
+      }
+      const reader = upstream.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let textBlockStarted = false;
+      let encounteredToolCall = false;
+      const toolAccum = {};
+      let usagePrompt = 0;
+      let usageCompletion = 0;
+      let usageCached = null;
+      let accumulatedContent = "";
+      let completed = false;
+      let firstTokenAt = null;
+      const encode = (event, data) => {
+        reply.raw.write(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`);
+      };
+      encode("message_start", {
+        type: "message_start",
+        message: {
+          id: `msg_${Math.random().toString(36).slice(2)}`,
+          type: "message",
+          role: "assistant",
+          model: target.modelId,
+          content: [],
+          stop_reason: null,
+          stop_sequence: null,
+          usage: { input_tokens: 0, output_tokens: 0 }
+        }
+      });
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done)
+          break;
+        if (!value)
+          continue;
+        const chunk = decoder.decode(value, { stream: true });
+        buffer += chunk;
+        const lines = buffer.split("\n");
+        if (!buffer.endsWith("\n")) {
+          buffer = lines.pop() ?? "";
+        } else {
+          buffer = "";
+        }
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed.startsWith("data:"))
+            continue;
+          const dataStr = trimmed.slice(5).trim();
+          if (dataStr === "[DONE]") {
+            if (encounteredToolCall) {
+              for (const idx of Object.keys(toolAccum)) {
+                encode("content_block_stop", {
+                  type: "content_block_stop",
+                  index: Number(idx)
+                });
+              }
+            } else if (textBlockStarted) {
+              encode("content_block_stop", {
+                type: "content_block_stop",
+                index: 0
+              });
+            }
+            const finalPromptTokens = usagePrompt || target.tokenEstimate || estimateTokens(normalized, target.modelId);
+            const finalCompletionTokens = usageCompletion || estimateTextTokens(accumulatedContent, target.modelId);
+            encode("message_delta", {
+              type: "message_delta",
+              delta: {
+                stop_reason: encounteredToolCall ? "tool_use" : "end_turn",
+                stop_sequence: null
+              },
+              usage: {
+                input_tokens: finalPromptTokens,
+                output_tokens: finalCompletionTokens
+              }
+            });
+            encode("message_stop", { type: "message_stop" });
+            reply.raw.write("\n");
+            reply.raw.end();
+            const totalLatencyMs = Date.now() - requestStart;
+            const ttftMs = firstTokenAt ? firstTokenAt - requestStart : null;
+            logUsage("stream.openai.final", {
+              input: finalPromptTokens,
+              output: finalCompletionTokens,
+              cached: usageCached
+            });
+            updateLogTokens(logId, {
+              inputTokens: finalPromptTokens,
+              outputTokens: finalCompletionTokens,
+              cachedTokens: usageCached,
+              ttftMs,
+              tpotMs: computeTpot(totalLatencyMs, finalCompletionTokens, {
+                streaming: true,
+                ttftMs
+              })
+            });
+            updateMetrics((/* @__PURE__ */ new Date()).toISOString().slice(0, 10), {
+              requests: 1,
+              inputTokens: finalPromptTokens,
+              outputTokens: finalCompletionTokens,
+              latencyMs: totalLatencyMs
+            });
+            if (storePayloads) {
+              upsertLogPayload(logId, {
+                response: (() => {
+                  try {
+                    return JSON.stringify({
+                      content: accumulatedContent,
+                      toolCalls: Object.keys(toolAccum).length > 0 ? toolAccum : void 0,
+                      usage: {
+                        input: finalPromptTokens,
+                        output: finalCompletionTokens,
+                        cached: usageCached
+                      }
+                    });
+                  } catch {
+                    return accumulatedContent;
+                  }
+                })()
+              });
+            }
+            finalize(200, null);
+            completed = true;
+            return reply;
+          }
+          let parsed;
+          try {
+            parsed = JSON.parse(dataStr);
+          } catch {
+            continue;
+          }
+          const choice = parsed.choices?.[0];
+          if (!choice)
+            continue;
+          const usagePayload = parsed.usage || choice.usage || choice.delta && choice.delta.usage || null;
+          if (usagePayload) {
+            usagePrompt = usagePayload.prompt_tokens ?? usagePrompt;
+            usageCompletion = usagePayload.completion_tokens ?? usageCompletion;
+            if (typeof usagePayload.cached_tokens === "number") {
+              usageCached = usagePayload.cached_tokens;
+            }
+          }
+          if (choice.delta?.tool_calls) {
+            if (!firstTokenAt) {
+              firstTokenAt = Date.now();
+            }
+            encounteredToolCall = true;
+            for (const toolCall of choice.delta.tool_calls) {
+              const idx = toolCall.index ?? 0;
+              if (toolAccum[idx] === void 0) {
+                toolAccum[idx] = "";
+                encode("content_block_start", {
+                  type: "content_block_start",
+                  index: idx,
+                  content_block: {
+                    type: "tool_use",
+                    id: toolCall.id || `tool_${Date.now()}_${idx}`,
+                    name: toolCall.function?.name,
+                    input: {}
+                  }
+                });
+              }
+              const deltaArgs = toolCall.function?.arguments || "";
+              if (deltaArgs) {
+                toolAccum[idx] += deltaArgs;
+                encode("content_block_delta", {
+                  type: "content_block_delta",
+                  index: idx,
+                  delta: {
+                    type: "input_json_delta",
+                    partial_json: deltaArgs
+                  }
+                });
+              }
+            }
+            continue;
+          }
+          if (choice.delta?.content) {
+            if (!firstTokenAt && choice.delta.content.length > 0) {
+              firstTokenAt = Date.now();
+            }
+            if (!textBlockStarted) {
+              textBlockStarted = true;
+              encode("content_block_start", {
+                type: "content_block_start",
+                index: 0,
+                content_block: {
+                  type: "text",
+                  text: ""
+                }
+              });
+            }
+            encode("content_block_delta", {
+              type: "content_block_delta",
+              index: 0,
+              delta: {
+                type: "text_delta",
+                text: choice.delta.content
+              }
+            });
+            accumulatedContent += choice.delta.content ?? "";
+          }
+          if (choice.delta?.reasoning) {
+            if (!firstTokenAt) {
+              firstTokenAt = Date.now();
+            }
+            if (!textBlockStarted) {
+              textBlockStarted = true;
+              encode("content_block_start", {
+                type: "content_block_start",
+                index: 0,
+                content_block: {
+                  type: "text",
+                  text: ""
+                }
+              });
+            }
+            encode("content_block_delta", {
+              type: "content_block_delta",
+              index: 0,
+              delta: {
+                type: "thinking_delta",
+                thinking: choice.delta.reasoning
+              }
+            });
+          }
+        }
+      }
+      if (!completed) {
+        reply.raw.end();
+        const totalLatencyMs = Date.now() - requestStart;
+        const fallbackPrompt = usagePrompt || target.tokenEstimate || estimateTokens(normalized, target.modelId);
+        const fallbackCompletion = usageCompletion || estimateTextTokens(accumulatedContent, target.modelId);
+        const ttftMs = firstTokenAt ? firstTokenAt - requestStart : null;
+        logUsage("stream.openai.fallback", {
+          input: fallbackPrompt,
+          output: fallbackCompletion,
+          cached: usageCached
+        });
+        updateLogTokens(logId, {
+          inputTokens: fallbackPrompt,
+          outputTokens: fallbackCompletion,
+          cachedTokens: usageCached,
+          ttftMs,
+          tpotMs: computeTpot(totalLatencyMs, fallbackCompletion, {
+            streaming: true,
+            ttftMs
+          })
+        });
+        updateMetrics((/* @__PURE__ */ new Date()).toISOString().slice(0, 10), {
+          requests: 1,
+          inputTokens: fallbackPrompt,
+          outputTokens: fallbackCompletion,
+          latencyMs: totalLatencyMs
+        });
+        if (storePayloads) {
+          upsertLogPayload(logId, {
+            response: (() => {
+              try {
+                return JSON.stringify({
+                  content: accumulatedContent,
+                  usage: {
+                    input: fallbackPrompt,
+                    output: fallbackCompletion,
+                    cached: usageCached
+                  }
+                });
+              } catch {
+                return accumulatedContent;
+              }
+            })()
+          });
+        }
+        finalize(200, null);
+        return reply;
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Unexpected error";
+      if (!reply.sent) {
+        reply.code(500);
+      }
+      finalize(reply.statusCode >= 400 ? reply.statusCode : 500, message);
+      return { error: message };
+    } finally {
+      decrementActiveRequests();
+      if (!finalized && reply.sent) {
+        finalize(reply.statusCode ?? 200, null);
+      }
+    }
+  });
+}
+
+// logging/queries.ts
+function queryLogs(options = {}) {
+  const db2 = getDb();
+  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;
+  }
+  if (options.model) {
+    conditions.push("model = @model");
+    params.model = options.model;
+  }
+  if (options.status === "success") {
+    conditions.push("error IS NULL");
+  } else if (options.status === "error") {
+    conditions.push("error IS NOT NULL");
+  }
+  if (typeof options.from === "number") {
+    conditions.push("timestamp >= @from");
+    params.from = options.from;
+  }
+  if (typeof options.to === "number") {
+    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
+       FROM request_logs
+       ${whereClause}
+       ORDER BY timestamp DESC
+       LIMIT @limit OFFSET @offset`
+  ).all({ ...params, limit, 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
+       FROM request_logs
+       WHERE id = ?`
+  ).get(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);
+  if (!payload) {
+    return null;
+  }
+  return {
+    prompt: decompressPayload(payload.prompt),
+    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);
+  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);
+  return rows.map((row) => ({
+    date: row.date,
+    requestCount: row.requestCount ?? 0,
+    inputTokens: row.inputTokens ?? 0,
+    outputTokens: row.outputTokens ?? 0,
+    avgLatencyMs: row.requestCount ? Math.round((row.totalLatency ?? 0) / row.requestCount) : 0
+  })).reverse();
+}
+function getMetricsOverview() {
+  const db2 = getDb();
+  const totalsRow = db2.prepare(
+    `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();
+  const todayKey = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const todayRow = db2.prepare(
+    `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);
+  const resolveAvg = (totalLatency, requests) => requests > 0 ? Math.round(totalLatency / requests) : 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,
+      avgLatencyMs: resolveAvg(totalsLatency, totalsRequests)
+    },
+    today: {
+      requests: todayRequests,
+      inputTokens: todayRow?.inputTokens ?? 0,
+      outputTokens: todayRow?.outputTokens ?? 0,
+      avgLatencyMs: resolveAvg(todayLatency, todayRequests)
+    }
+  };
+}
+function getModelUsageMetrics(days = 7, limit = 10) {
+  const db2 = getDb();
+  const since = Date.now() - days * 24 * 60 * 60 * 1e3;
+  const rows = db2.prepare(
+    `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);
+  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
+  }));
+}
+
+// routes/admin.ts
+async function registerAdminRoutes(app) {
+  app.get("/api/status", async () => {
+    const config = getConfig();
+    return {
+      port: config.port,
+      host: config.host,
+      providers: config.providers.length,
+      activeRequests: getActiveRequestCount()
+    };
+  });
+  app.get("/api/providers", async () => {
+    const config = getConfig();
+    return config.providers;
+  });
+  app.get("/api/config", async () => {
+    return getConfig();
+  });
+  app.get("/api/config/info", async () => {
+    const config = getConfig();
+    return {
+      config,
+      path: CONFIG_PATH
+    };
+  });
+  app.put("/api/config", async (request, reply) => {
+    const body = request.body;
+    if (!body || typeof body.port !== "number") {
+      reply.code(400);
+      return { error: "Invalid config payload" };
+    }
+    updateConfig(body);
+    return { success: true };
+  });
+  app.post("/api/providers/:id/test", async (request, reply) => {
+    const id = String(request.params.id);
+    const config = getConfig();
+    const provider = config.providers.find((item) => item.id === id);
+    if (!provider) {
+      reply.code(404);
+      return { error: "Provider not found" };
+    }
+    const startedAt = Date.now();
+    const targetModel = provider.defaultModel || provider.models?.[0]?.id;
+    if (!targetModel) {
+      reply.code(400);
+      return {
+        ok: false,
+        status: 0,
+        statusText: "No model configured for provider"
+      };
+    }
+    const testPayload = normalizeClaudePayload({
+      model: targetModel,
+      stream: false,
+      temperature: 0,
+      messages: [
+        {
+          role: "user",
+          content: [
+            {
+              type: "text",
+              text: "\u4F60\u597D\uFF0C\u8FD9\u662F\u4E00\u6B21\u8FDE\u63A5\u6D4B\u8BD5\u3002\u8BF7\u7B80\u77ED\u56DE\u5E94\u4EE5\u786E\u8BA4\u670D\u52A1\u53EF\u7528\u3002"
+            }
+          ]
+        }
+      ],
+      system: "You are a connection diagnostic assistant."
+    });
+    const providerBody = provider.type === "anthropic" ? buildAnthropicBody(testPayload, {
+      maxTokens: provider.models?.find((m) => m.id === targetModel)?.maxTokens ?? 256,
+      temperature: 0,
+      toolChoice: void 0,
+      overrideTools: void 0
+    }) : buildProviderBody(testPayload, {
+      maxTokens: provider.models?.find((m) => m.id === targetModel)?.maxTokens ?? 256,
+      temperature: 0,
+      toolChoice: void 0,
+      overrideTools: void 0
+    });
+    const connector = getConnector(provider.id);
+    try {
+      const upstream = await connector.send({
+        model: targetModel,
+        body: providerBody,
+        stream: false
+      });
+      const duration = Date.now() - startedAt;
+      if (upstream.status >= 400) {
+        const errorText = upstream.body ? await new Response(upstream.body).text() : "";
+        return {
+          ok: false,
+          status: upstream.status,
+          statusText: errorText || "Upstream error",
+          durationMs: duration
+        };
+      }
+      const raw = upstream.body ? await new Response(upstream.body).text() : "";
+      let parsed = null;
+      try {
+        parsed = raw ? JSON.parse(raw) : null;
+      } catch {
+        return {
+          ok: false,
+          status: upstream.status,
+          statusText: "Invalid JSON response",
+          durationMs: duration
+        };
+      }
+      let sample = "";
+      if (provider.type === "anthropic") {
+        const contentBlocks = Array.isArray(parsed?.content) ? parsed.content : [];
+        const textBlocks = contentBlocks.filter((block) => block?.type === "text" && typeof block.text === "string").map((block) => block.text);
+        sample = textBlocks.join("\n");
+      } else {
+        const choice = Array.isArray(parsed?.choices) ? parsed.choices[0] : null;
+        if (choice) {
+          if (Array.isArray(choice.message?.content)) {
+            sample = choice.message.content.join("\n");
+          } else {
+            sample = choice.message?.content ?? choice.text ?? "";
+          }
+        }
+      }
+      sample = typeof sample === "string" ? sample.trim() : "";
+      return {
+        ok: Boolean(sample),
+        status: upstream.status,
+        statusText: sample ? "OK" : "Empty response",
+        durationMs: duration,
+        sample: sample ? sample.slice(0, 200) : null
+      };
+    } catch (error) {
+      reply.code(502);
+      return {
+        ok: false,
+        status: 0,
+        statusText: error instanceof Error ? error.message : "Network error",
+        durationMs: Date.now() - startedAt
+      };
+    }
+  });
+  app.get("/api/logs", async (request, reply) => {
+    const query = request.query ?? {};
+    const limitRaw = Number(query.limit ?? 50);
+    const offsetRaw = Number(query.offset ?? 0);
+    const limit = Number.isFinite(limitRaw) ? Math.min(Math.max(limitRaw, 1), 200) : 50;
+    const offset = Number.isFinite(offsetRaw) ? Math.max(offsetRaw, 0) : 0;
+    const provider = typeof query.provider === "string" && query.provider.length > 0 ? query.provider : void 0;
+    const model = typeof query.model === "string" && query.model.length > 0 ? query.model : void 0;
+    const statusParam = typeof query.status === "string" ? query.status : void 0;
+    const status = statusParam === "success" || statusParam === "error" ? statusParam : void 0;
+    const parseTime = (value) => {
+      if (!value)
+        return void 0;
+      const numeric = Number(value);
+      if (Number.isFinite(numeric))
+        return numeric;
+      const parsed = Date.parse(value);
+      return Number.isFinite(parsed) ? parsed : void 0;
+    };
+    const from = parseTime(query.from);
+    const to = parseTime(query.to);
+    const { items, total } = queryLogs({ limit, offset, provider, model, status, from, to });
+    reply.header("x-total-count", String(total));
+    return { total, items };
+  });
+  app.get("/api/logs/:id", async (request, reply) => {
+    const id = Number(request.params.id);
+    if (!Number.isFinite(id)) {
+      reply.code(400);
+      return { error: "Invalid id" };
+    }
+    const record = getLogDetail(id);
+    if (!record) {
+      reply.code(404);
+      return { error: "Not found" };
+    }
+    const payload = getLogPayload(id);
+    return { ...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);
+    return { success: true, deleted };
+  });
+  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 });
+    return {
+      pageCount,
+      pageSize,
+      sizeBytes: pageCount * pageSize
+    };
+  });
+  app.get("/api/stats/overview", async () => {
+    return getMetricsOverview();
+  });
+  app.get("/api/stats/daily", async (request) => {
+    const query = request.query ?? {};
+    const daysRaw = Number(query.days ?? 7);
+    const days = Number.isFinite(daysRaw) ? Math.max(1, Math.min(daysRaw, 30)) : 7;
+    return getDailyMetrics(days);
+  });
+  app.get("/api/stats/model", async (request) => {
+    const query = request.query ?? {};
+    const daysRaw = Number(query.days ?? 7);
+    const limitRaw = Number(query.limit ?? 10);
+    const days = Number.isFinite(daysRaw) ? Math.max(1, Math.min(daysRaw, 90)) : 7;
+    const limit = Number.isFinite(limitRaw) ? Math.max(1, Math.min(limitRaw, 50)) : 10;
+    return getModelUsageMetrics(days, limit);
+  });
+}
+
+// tasks/maintenance.ts
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var timersStarted = false;
+function startMaintenanceTimers() {
+  if (timersStarted)
+    return;
+  timersStarted = true;
+  scheduleCleanup();
+}
+function scheduleCleanup() {
+  const run = () => {
+    try {
+      const retentionDays = getConfig().logRetentionDays ?? 30;
+      const cutoff = Date.now() - retentionDays * DAY_MS;
+      const deleted = cleanupLogsBefore(cutoff);
+      if (deleted > 0) {
+        console.info(`[maintenance] cleaned ${deleted} old log entries`);
+      }
+    } catch (err) {
+      console.error("[maintenance] cleanup failed", err);
+    }
+  };
+  setInterval(run, DAY_MS);
+}
+
+// index.ts
+var DEFAULT_PORT = 3456;
+var DEFAULT_HOST = "127.0.0.1";
+var cachedConfig2 = loadConfig();
+onConfigChange((config) => {
+  cachedConfig2 = config;
+});
+function resolveWebDist() {
+  const __filename2 = fileURLToPath(import.meta.url);
+  const __dirname = path3.dirname(__filename2);
+  const candidates = [
+    process2.env.CC_GW_UI_ROOT,
+    path3.resolve(__dirname, "../web/public"),
+    path3.resolve(__dirname, "../web/dist"),
+    path3.resolve(__dirname, "../../web/dist"),
+    path3.resolve(__dirname, "../../../src/web/dist"),
+    path3.resolve(process2.cwd(), "src/web/dist")
+  ].filter((item) => Boolean(item));
+  for (const candidate of candidates) {
+    if (fs3.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+async function createServer() {
+  const app = Fastify({ logger: true });
+  await app.register(fastifyCors, {
+    origin: true,
+    credentials: true
+  });
+  const webRoot = resolveWebDist();
+  if (webRoot) {
+    await app.register(fastifyStatic, {
+      root: webRoot,
+      prefix: "/ui/"
+    });
+    app.get("/", async (_, reply) => reply.redirect("/ui/"));
+    app.get("/ui", async (_, reply) => reply.redirect("/ui/"));
+    const assetHandler = async (request, reply) => {
+      const params = request.params;
+      const target = params["*"] ?? "";
+      if (target.includes("..")) {
+        reply.code(400);
+        return { error: "Invalid asset path" };
+      }
+      return reply.sendFile(path3.join("assets", target));
+    };
+    app.get("/assets/*", assetHandler);
+    app.head("/assets/*", assetHandler);
+    const faviconHandler = async (_, reply) => reply.sendFile("favicon.ico");
+    app.get("/favicon.ico", faviconHandler);
+    app.head("/favicon.ico", faviconHandler);
+    app.setNotFoundHandler((request, reply) => {
+      const url = request.raw.url ?? "";
+      if (url.startsWith("/ui/")) {
+        reply.type("text/html");
+        return reply.sendFile("index.html");
+      }
+      reply.code(404).send({ error: "Not Found" });
+    });
+  } else {
+    app.log.warn("\u672A\u627E\u5230 Web UI \u6784\u5EFA\u4EA7\u7269\uFF0C/ui \u76EE\u5F55\u5C06\u4E0D\u53EF\u7528\u3002");
+  }
+  await registerMessagesRoute(app);
+  await registerAdminRoutes(app);
+  startMaintenanceTimers();
+  app.get("/health", async () => {
+    return {
+      status: "ok",
+      timestamp: Date.now(),
+      providerCount: getConfig().providers.length
+    };
+  });
+  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;
+}
+async function main() {
+  try {
+    const app = await startServer();
+    const shutdown = async () => {
+      try {
+        await app.close();
+        process2.exit(0);
+      } catch (err) {
+        app.log.error({ err }, "\u5173\u95ED\u670D\u52A1\u5931\u8D25");
+        process2.exit(1);
+      }
+    };
+    process2.on("SIGTERM", shutdown);
+    process2.on("SIGINT", shutdown);
+  } catch (err) {
+    console.error("\u542F\u52A8\u670D\u52A1\u5931\u8D25", err);
+    process2.exit(1);
+  }
+}
+var __filename = fileURLToPath(import.meta.url);
+if (process2.argv[1] && path3.resolve(process2.argv[1]) === __filename) {
+  main();
+}
+export {
+  createServer,
+  startServer
+};