qwenproxy-cli 1.0.0

package/src/core/memory-usage.ts

@@ -0,0 +1,84 @@
+import v8 from "v8";
+import os from "os";
+
+/**
+ * Heap pressure relative to V8 heap_size_limit (not heapTotal).
+ * heapUsed/heapTotal is almost always high (~95%+) and caused false criticals.
+ */
+export interface HeapUsageSnapshot {
+  heapUsed: number;
+  heapTotal: number;
+  heapSizeLimit: number;
+  rss: number;
+  usagePercent: number;
+}
+
+export function getHeapUsageSnapshot(
+  mem: NodeJS.MemoryUsage = process.memoryUsage(),
+  heapSizeLimit: number = v8.getHeapStatistics().heap_size_limit,
+): HeapUsageSnapshot {
+  const limit =
+    Number.isFinite(heapSizeLimit) && heapSizeLimit > 0
+      ? heapSizeLimit
+      : Math.max(mem.heapTotal, 1);
+  const usagePercent = (mem.heapUsed / limit) * 100;
+  return {
+    heapUsed: mem.heapUsed,
+    heapTotal: mem.heapTotal,
+    heapSizeLimit: limit,
+    rss: mem.rss,
+    usagePercent,
+  };
+}
+
+export function classifyRamUsage(
+  usagePercent: number,
+  warningThreshold: number,
+  criticalThreshold: number,
+): "ok" | "warning" | "critical" {
+  if (usagePercent > criticalThreshold) return "critical";
+  if (usagePercent > warningThreshold) return "warning";
+  return "ok";
+}
+
+/**
+ * RSS pressure relative to TOTAL system memory. The heap-vs-limit ratio misses
+ * Playwright browser processes (RSS lives outside the V8 heap); RSS vs total
+ * RAM is the metric that actually predicts OOM on a VPS.
+ */
+export interface RssUsageSnapshot {
+  rss: number;
+  totalSystemMemory: number;
+  /** RSS as a percentage of total system memory. */
+  usagePercent: number;
+}
+
+export function getRssUsageSnapshot(
+  mem: NodeJS.MemoryUsage = process.memoryUsage(),
+  totalSystemMemory: number = os.totalmem(),
+): RssUsageSnapshot {
+  const usagePercent =
+    Number.isFinite(totalSystemMemory) && totalSystemMemory > 0
+      ? (mem.rss / totalSystemMemory) * 100
+      : 0;
+  return {
+    rss: mem.rss,
+    totalSystemMemory,
+    usagePercent,
+  };
+}
+
+/** % of system RAM used by this process (RSS), rounded to one decimal. */
+export function getMemoryUsagePct(
+  mem: NodeJS.MemoryUsage = process.memoryUsage(),
+  totalSystemMemory: number = os.totalmem(),
+): number {
+  const snap = getRssUsageSnapshot(mem, totalSystemMemory);
+  if (
+    !Number.isFinite(snap.rss) ||
+    snap.totalSystemMemory <= 0
+  ) {
+    return 0;
+  }
+  return Number(snap.usagePercent.toFixed(1));
+}

package/src/core/metrics.ts

@@ -0,0 +1,291 @@
+import { EventEmitter } from "events";
+import { config } from "./config.js";
+import { getHeapUsageSnapshot, getRssUsageSnapshot } from "./memory-usage.js";
+
+interface MetricPoint {
+  value: number;
+  timestamp: number;
+  labels?: Record<string, string>;
+}
+
+type MetricType = "counter" | "gauge" | "histogram" | "summary";
+
+interface MetricDefinition {
+  name: string;
+  type: MetricType;
+  help: string;
+  values: Map<string, MetricPoint>;
+  histogramBuckets?: number[];
+}
+
+export class Metrics extends EventEmitter {
+  private metrics: Map<string, MetricDefinition> = new Map();
+  private collectionInterval: NodeJS.Timeout | null = null;
+
+  constructor() {
+    super();
+    this.registerDefaults();
+  }
+
+  private registerDefaults(): void {
+    const defaults: Array<[string, MetricType, string]> = [
+      // Core request metrics
+      ["requests.total", "counter", "Total requests processed"],
+      ["requests.errors", "counter", "Total request errors"],
+      ["latency.request", "histogram", "Request latency (ms)"],
+
+      // Stream metrics
+      ["streams.active", "gauge", "Active SSE streams"],
+      ["streams.errors", "counter", "Stream errors"],
+
+      // CAPTCHA / anti-bot metrics
+      ["captcha.challenges.detected", "counter", "Detected CAPTCHA challenges"],
+      ["captcha.solves.succeeded", "counter", "Successful CAPTCHA solves"],
+      ["captcha.solves.failed", "counter", "Failed CAPTCHA solves"],
+      ["captcha.solve.duration", "histogram", "CAPTCHA solve duration (ms)"],
+
+      // Memory metrics
+      ["memory.heap.used", "gauge", "Heap memory used (bytes)"],
+      ["memory.heap.total", "gauge", "Heap memory total (bytes)"],
+      [
+        "memory.heap.limit",
+        "gauge",
+        "V8 heap_size_limit used for RAM pressure (bytes)",
+      ],
+      [
+        "memory.heap.usage_percent",
+        "gauge",
+        "Heap used percent vs heap_size_limit",
+      ],
+      ["memory.rss", "gauge", "Resident set size (bytes)"],
+      [
+        "memory.rss.usage_percent",
+        "gauge",
+        "RSS as percent of total system memory (RAM pressure signal)",
+      ],
+
+      // Cache metrics
+      ["cache.set", "counter", "Cache set operations"],
+      ["cache.hit", "counter", "Cache hits"],
+      ["cache.miss", "counter", "Cache misses"],
+      ["cache.deleted", "counter", "Cache deletions"],
+      ["cache.flushed", "counter", "Cache flushes"],
+      ["cache.value.size", "histogram", "Cache value size (bytes)"],
+      ["cache.get.latency", "histogram", "Cache get latency (ms)"],
+      ["cache.hit.ratio", "gauge", "Cache hit ratio (hits / (hits + misses))"],
+      [
+        "cache.compression.ratio",
+        "histogram",
+        "Compression ratio (original / compressed)",
+      ],
+      [
+        "cache.compression.bytes.saved",
+        "counter",
+        "Total bytes saved by compression",
+      ],
+      [
+        "cache.topic.invalidation",
+        "counter",
+        "Cache entries invalidated by topic change",
+      ],
+      [
+        "cache.memory.usage.bytes",
+        "gauge",
+        "Estimated cache memory usage (bytes)",
+      ],
+      ["cache.entries.count", "gauge", "Current number of cache entries"],
+      [
+        "topic.change.detected",
+        "counter",
+        "Detected conversation topic changes",
+      ],
+
+      // Watchdog metrics
+      [
+        "watchdog.ram.status",
+        "gauge",
+        "Watchdog RAM status (0=ok, 1=warning, 2=critical)",
+      ],
+      [
+        "watchdog.overall",
+        "gauge",
+        "Watchdog overall status (0=healthy, 1=degraded, 2=unhealthy)",
+      ],
+      ["watchdog.recovery.triggered", "counter", "Recovery attempts triggered"],
+      ["watchdog.recovery.success", "counter", "Successful recoveries"],
+      ["watchdog.recovery.failed", "counter", "Failed recoveries"],
+    ];
+
+    for (const [name, type, help] of defaults) {
+      this.metrics.set(name, {
+        name,
+        type,
+        help,
+        values: new Map(),
+        histogramBuckets:
+          type === "histogram"
+            ? [5, 10, 25, 50, 100, 250, 500, 1000, 2500, 5000]
+            : undefined,
+      });
+    }
+  }
+
+  increment(
+    name: string,
+    value: number = 1,
+    labels?: Record<string, string>,
+  ): void {
+    const metric = this.metrics.get(name);
+    if (!metric || metric.type !== "counter") return;
+
+    const key = labels ? JSON.stringify(labels) : "default";
+    // Mutate in place to avoid reallocating a MetricPoint on every increment.
+    const point = metric.values.get(key);
+    if (point) {
+      point.value += value;
+      point.timestamp = Date.now();
+    } else {
+      metric.values.set(key, { value, timestamp: Date.now(), labels });
+    }
+  }
+
+  gauge(name: string, value: number, labels?: Record<string, string>): void {
+    const metric = this.metrics.get(name);
+    if (!metric || metric.type !== "gauge") return;
+
+    const key = labels ? JSON.stringify(labels) : "default";
+    const point = metric.values.get(key);
+    if (point) {
+      point.value = value;
+      point.timestamp = Date.now();
+    } else {
+      metric.values.set(key, { value, timestamp: Date.now(), labels });
+    }
+  }
+
+  histogram(
+    name: string,
+    value: number,
+    labels?: Record<string, string>,
+  ): void {
+    const metric = this.metrics.get(name);
+    if (!metric || metric.type !== "histogram") return;
+
+    const key = labels ? JSON.stringify(labels) : "default";
+    const existing = metric.values.get(key);
+    // Reuse the stored aggregate object instead of re-wrapping it each call.
+    let data: { count: number; sum: number; buckets: Map<number, number> };
+    if (existing && typeof existing.value === "object" && existing.value !== null) {
+      data = existing.value as { count: number; sum: number; buckets: Map<number, number> };
+    } else {
+      data = { count: 0, sum: 0, buckets: new Map<number, number>() };
+    }
+
+    data.count++;
+    data.sum += value;
+    const buckets = metric.histogramBuckets;
+    if (buckets) {
+      for (let i = 0; i < buckets.length; i++) {
+        const bucket = buckets[i];
+        if (value <= bucket) {
+          data.buckets.set(bucket, (data.buckets.get(bucket) || 0) + 1);
+        } else if (!data.buckets.has(bucket)) {
+          // Keep every bucket present for stable output, but skip redundant writes.
+          data.buckets.set(bucket, 0);
+        }
+      }
+    }
+
+    if (existing) {
+      existing.value = data as any;
+      existing.timestamp = Date.now();
+    } else {
+      metric.values.set(key, { value: data as any, timestamp: Date.now(), labels });
+    }
+  }
+
+  startCollection(): void {
+    if (this.collectionInterval) return;
+
+    this.collectionInterval = setInterval(() => {
+      this.collectSystemMetrics();
+    }, config.metrics.interval);
+  }
+
+  private collectSystemMetrics(): void {
+    const heap = getHeapUsageSnapshot();
+    const rss = getRssUsageSnapshot();
+    this.gauge("memory.heap.used", heap.heapUsed);
+    this.gauge("memory.heap.total", heap.heapTotal);
+    this.gauge("memory.heap.limit", heap.heapSizeLimit);
+    this.gauge("memory.heap.usage_percent", heap.usagePercent);
+    this.gauge("memory.rss", heap.rss);
+    this.gauge("memory.rss.usage_percent", rss.usagePercent);
+  }
+
+  get(name: string, labels?: Record<string, string>): MetricPoint | null {
+    const metric = this.metrics.get(name);
+    if (!metric) return null;
+    const key = labels ? JSON.stringify(labels) : "default";
+    return metric.values.get(key) || null;
+  }
+
+  formatPrometheus(): string {
+    let output = "";
+    for (const metric of this.metrics.values()) {
+      output += `# HELP ${metric.name} ${metric.help}\n`;
+      output += `# TYPE ${metric.name} ${metric.type}\n`;
+
+      for (const point of metric.values.values()) {
+        const labelPairs = point.labels
+          ? Object.entries(point.labels).map(([k, v]) => `${k}="${v}"`)
+          : [];
+        const labelsStr = labelPairs.length ? `{${labelPairs.join(",")}}` : "";
+
+        if (
+          metric.type === "histogram" &&
+          typeof point.value === "object" &&
+          point.value !== null
+        ) {
+          // Histogram points store a {count, sum, buckets} aggregate; emitting
+          // it raw produced "[object Object]" (invalid Prometheus exposition).
+          const data = point.value as {
+            count: number;
+            sum: number;
+            buckets: Map<number, number>;
+          };
+          const bucketPrefix = labelPairs.length
+            ? `${labelPairs.join(",")},`
+            : "";
+          const sortedBuckets = [...data.buckets.keys()].sort((a, b) => a - b);
+          for (const bucket of sortedBuckets) {
+            output += `${metric.name}_bucket{${bucketPrefix}le="${bucket}"} ${data.buckets.get(bucket)} ${point.timestamp}\n`;
+          }
+          output += `${metric.name}_bucket{${bucketPrefix}le="+Inf"} ${data.count} ${point.timestamp}\n`;
+          output += `${metric.name}_sum${labelsStr} ${data.sum} ${point.timestamp}\n`;
+          output += `${metric.name}_count${labelsStr} ${data.count} ${point.timestamp}\n`;
+          continue;
+        }
+
+        output += `${metric.name}${labelsStr} ${point.value} ${point.timestamp}\n`;
+      }
+    }
+    return output;
+  }
+
+  reset(): void {
+    for (const metric of this.metrics.values()) {
+      metric.values.clear();
+    }
+    this.emit("reset", {});
+  }
+
+  stopCollection(): void {
+    if (this.collectionInterval) {
+      clearInterval(this.collectionInterval);
+      this.collectionInterval = null;
+    }
+  }
+}
+
+export const metrics = new Metrics();

package/src/core/model-alias.ts

@@ -0,0 +1,77 @@
+/**
+ * Modo de raciocínio para modelos Qwen:
+ * - "auto": Qwen decide se usa thinking (padrão)
+ * - "thinking": força thinking ON
+ * - "fast": força thinking OFF
+ */
+export type ReasoningMode = "auto" | "thinking" | "fast";
+
+/**
+ * Resolução de variantes de raciocínio dos modelos Qwen públicos.
+ *
+ * Mapeamento padronizado de sufixos de esforço de raciocínio:
+ * - `-low`: força thinking OFF (Fast)
+ * - `-medium`: thinking AUTO (Qwen decide dinamicamente)
+ * - `-high`: força thinking ON (Thinking profundo)
+ *
+ * Sufixos legados (`-fast`, `-thinking`, `-no-thinking`) são mantidos
+ * para total compatibilidade regressiva. O modelo base limpo é sempre
+ * retornado para o upstream e publicado sem duplicatas em `/v1/models`.
+ */
+export function stripThinkingSuffix(model: string): {
+  baseModel: string;
+  enableThinking: boolean;
+  reasoningMode: ReasoningMode;
+} {
+  const normalizedModel = model.trim();
+
+  // Fast / Low path (thinking off)
+  if (
+    normalizedModel.endsWith("-low") ||
+    normalizedModel.endsWith("-fast") ||
+    normalizedModel.endsWith("-no-thinking")
+  ) {
+    return {
+      baseModel: normalizedModel.replace(/-(?:low|fast|no-thinking)$/, ""),
+      enableThinking: false,
+      reasoningMode: "fast",
+    };
+  }
+
+  // Medium path (auto thinking - Qwen decides dynamically)
+  if (normalizedModel.endsWith("-medium")) {
+    return {
+      baseModel: normalizedModel.slice(0, -"-medium".length),
+      enableThinking: true,
+      reasoningMode: "auto",
+    };
+  }
+
+  // High / Thinking path (thinking on)
+  if (
+    normalizedModel.endsWith("-high") ||
+    normalizedModel.endsWith("-thinking")
+  ) {
+    return {
+      baseModel: normalizedModel.replace(/-(?:high|thinking)$/, ""),
+      enableThinking: true,
+      reasoningMode: "thinking",
+    };
+  }
+
+  // Default: auto thinking (Qwen decides)
+  return { baseModel: normalizedModel, enableThinking: true, reasoningMode: "auto" };
+}
+
+/**
+ * Mapeia o id de modelo para o Qwen upstream.
+ * Ids `qwen*` passam direto (após remover o sufixo de raciocínio); ids de
+ * outros provedores (gpt-*, grok-*, etc.) também passam “as-is” — o Codex/Custom
+ * provider envia o id Qwen correto, e qualquer id desconhecido deve chegar ao
+ * upstream para que este responda um erro claro de modelo, em vez de ser
+ * silenciosamente roteado para um tier qualquer.
+ */
+export function mapClientModelToQwen(model: string): string {
+  if (!model) return model;
+  return stripThinkingSuffix(model.trim()).baseModel;
+}