@pedrofariasx/qwenproxy 1.1.0

package/src/core/metrics.ts

@@ -0,0 +1,169 @@
+import { EventEmitter } from 'events'
+import { config } from './config.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
+  private exportCallback: ((metrics: Map<string, MetricDefinition>) => void) | null = null
+
+  constructor() {
+    super()
+    this.registerDefaults()
+  }
+
+  private registerDefaults(): void {
+    const defaults: Array<[string, MetricType, string]> = [
+      ['requests.total', 'counter', 'Total requests processed'],
+      ['requests.errors', 'counter', 'Total request errors'],
+      ['latency.request', 'histogram', 'Request latency (ms)'],
+      ['streams.active', 'gauge', 'Active SSE streams'],
+      ['streams.errors', 'counter', 'Stream errors'],
+      ['memory.heap.used', 'gauge', 'Heap memory used (bytes)'],
+      ['memory.heap.total', 'gauge', 'Heap memory total (bytes)'],
+      ['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)'],
+      ['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'
+    const current = metric.values.get(key)?.value || 0
+    metric.values.set(key, { value: current + value, timestamp: Date.now(), labels })
+    this.emit('metric', { name, type: 'counter', value: current + value, labels })
+  }
+
+  decrement(name: string, labels?: Record<string, string>): void {
+    this.increment(name, -1, 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'
+    metric.values.set(key, { value, timestamp: Date.now(), labels })
+    this.emit('metric', { name, type: 'gauge', value, 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)
+    const data = existing?.value || { count: 0, sum: 0, buckets: new Map<number, number>() }
+
+    if (typeof data === 'object' && data !== null) {
+      data.count++
+      data.sum += value
+      for (const bucket of metric.histogramBuckets || []) {
+        data.buckets.set(bucket, (data.buckets.get(bucket) || 0) + (value <= bucket ? 1 : 0))
+      }
+    }
+
+    metric.values.set(key, { value: data as any, timestamp: Date.now(), labels })
+    this.emit('metric', { name, type: 'histogram', value, labels })
+  }
+
+  startCollection(): void {
+    if (this.collectionInterval) return
+
+    this.collectionInterval = setInterval(() => {
+      this.collectSystemMetrics()
+      if (this.exportCallback) {
+        this.exportCallback(this.metrics)
+      }
+    }, config.metrics.interval)
+  }
+
+  private collectSystemMetrics(): void {
+    const mem = process.memoryUsage()
+    this.gauge('memory.heap.used', mem.heapUsed)
+    this.gauge('memory.heap.total', mem.heapTotal)
+  }
+
+  setExportCallback(callback: (metrics: Map<string, MetricDefinition>) => void): void {
+    this.exportCallback = callback
+  }
+
+  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
+  }
+
+  getAll(): Map<string, MetricDefinition> {
+    return new Map(this.metrics)
+  }
+
+  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 [key, point] of metric.values) {
+        const labelsStr = point.labels
+          ? `{${Object.entries(point.labels).map(([k, v]) => `${k}="${v}"`).join(',')}}`
+          : ''
+        output += `${metric.name}${labelsStr} ${point.value} ${point.timestamp}\n`
+      }
+    }
+    return output
+  }
+
+  reset(): void {
+    for (const metric of this.metrics.values()) {
+      metric.values.clear()
+    }
+  }
+
+  stopCollection(): void {
+    if (this.collectionInterval) {
+      clearInterval(this.collectionInterval)
+      this.collectionInterval = null
+    }
+  }
+}
+
+export const metrics = new Metrics()

package/src/core/model-registry.ts

@@ -0,0 +1,30 @@
+const modelContextWindows: Record<string, number> = {
+  'qwen-max': 32768,
+  'qwen-max-latest': 32768,
+  'qwen-plus': 131072,
+  'qwen-plus-latest': 131072,
+  'qwen-turbo': 131072,
+  'qwen-turbo-latest': 131072,
+  'qwen-long': 1000000,
+  'qwen-coder': 131072,
+  'qwen-coder-plus': 131072,
+}
+
+const defaultContextWindow = 131072
+
+export function setModelContextWindow(modelId: string, contextWindow: number): void {
+  modelContextWindows[modelId] = contextWindow
+}
+
+export function getModelContextWindow(modelId: string): number {
+  const baseId = modelId.replace('-no-thinking', '')
+  return modelContextWindows[baseId] ?? defaultContextWindow
+}
+
+export function syncModelContextWindows(models: Array<{ id: string; context_window?: number }>): void {
+  for (const m of models) {
+    if (m.context_window) {
+      modelContextWindows[m.id] = m.context_window
+    }
+  }
+}

package/src/core/stream-registry.ts

@@ -0,0 +1,40 @@
+import { metrics } from './metrics.js'
+
+const activeStreams = new Map<string, {
+  abortController: AbortController;
+  accountId: string;
+  uiSessionId: string;
+  targetResponseId: string;
+  headers: Record<string, string>;
+}>();
+
+export function registerStream(key: string, entry: {
+  abortController: AbortController;
+  accountId: string;
+  uiSessionId: string;
+  targetResponseId: string;
+  headers: Record<string, string>;
+}): void {
+  activeStreams.set(key, entry)
+  metrics.gauge('streams.active', activeStreams.size)
+}
+
+export function getStream(key: string): ReturnType<typeof activeStreams.get> {
+  return activeStreams.get(key)
+}
+
+export function removeStream(key: string): void {
+  activeStreams.delete(key)
+  metrics.gauge('streams.active', activeStreams.size)
+}
+
+export function abortStream(key: string): boolean {
+  const entry = activeStreams.get(key)
+  if (entry) {
+    entry.abortController.abort()
+    activeStreams.delete(key)
+    metrics.gauge('streams.active', activeStreams.size)
+    return true
+  }
+  return false
+}

package/src/core/watchdog.ts

@@ -0,0 +1,130 @@
+import { EventEmitter } from 'events'
+import { config } from './config.js'
+import { metrics } from './metrics.js'
+
+interface HealthStatus {
+  ram: 'ok' | 'warning' | 'critical'
+  streams: 'ok' | 'congested' | 'blocked'
+  overall: 'healthy' | 'degraded' | 'unhealthy'
+}
+
+export class Watchdog extends EventEmitter {
+  private checkInterval: NodeJS.Timeout | null = null
+  private consecutiveFailures: number = 0
+  private recoveryInProgress: boolean = false
+
+  start(): void {
+    if (this.checkInterval) return
+
+    this.checkInterval = setInterval(() => {
+      this.performHealthCheck().catch(error => {
+        this.emit('check:error', error)
+        this.consecutiveFailures++
+      })
+    }, config.watchdog.checkInterval)
+
+    this.emit('started')
+  }
+
+  private async performHealthCheck(): Promise<void> {
+    const status: HealthStatus = {
+      ram: this.checkRAM(),
+      streams: this.checkStreams(),
+      overall: 'healthy',
+    }
+
+    status.overall = this.calculateOverall(status)
+
+    if (status.overall === 'unhealthy') {
+      this.consecutiveFailures++
+      if (this.consecutiveFailures >= config.watchdog.consecutiveFailuresThreshold && !this.recoveryInProgress) {
+        await this.triggerRecovery(status)
+      }
+    } else {
+      this.consecutiveFailures = 0
+    }
+
+    this.emit('health:check', status)
+    metrics.gauge('watchdog.ram.status', status.ram === 'ok' ? 0 : status.ram === 'warning' ? 1 : 2)
+    metrics.gauge('watchdog.overall', status.overall === 'healthy' ? 0 : status.overall === 'degraded' ? 1 : 2)
+  }
+
+  private checkRAM(): 'ok' | 'warning' | 'critical' {
+    const mem = process.memoryUsage()
+    const usagePercent = (mem.heapUsed / mem.heapTotal) * 100
+
+    if (usagePercent > config.watchdog.ram.criticalThreshold) return 'critical'
+    if (usagePercent > config.watchdog.ram.warningThreshold) return 'warning'
+    return 'ok'
+  }
+
+  private checkStreams(): 'ok' | 'congested' | 'blocked' {
+    const activeStreams = metrics.get('streams.active')?.value || 0
+    if (activeStreams > config.watchdog.streams.criticalThreshold) return 'blocked'
+    if (activeStreams > config.watchdog.streams.warningThreshold) return 'congested'
+    return 'ok'
+  }
+
+  private calculateOverall(status: HealthStatus): 'healthy' | 'degraded' | 'unhealthy' {
+    const critical = ['critical', 'blocked']
+    const warning = ['warning', 'congested']
+
+    const values = Object.values(status).filter(v => typeof v === 'string') as string[]
+    if (values.some(v => critical.includes(v))) return 'unhealthy'
+    if (values.some(v => warning.includes(v))) return 'degraded'
+    return 'healthy'
+  }
+
+  private async triggerRecovery(status: HealthStatus): Promise<void> {
+    if (this.recoveryInProgress) return
+    this.recoveryInProgress = true
+
+    this.emit('recovery:start', status)
+    metrics.increment('watchdog.recovery.triggered')
+
+    try {
+      if (status.ram === 'critical') {
+        await this.recoverRAM()
+      }
+      if (status.streams === 'blocked') {
+        await this.recoverStreams()
+      }
+
+      this.emit('recovery:complete')
+      metrics.increment('watchdog.recovery.success')
+    } catch (error: any) {
+      this.emit('recovery:error', error)
+      metrics.increment('watchdog.recovery.failed')
+    } finally {
+      this.recoveryInProgress = false
+    }
+  }
+
+  private async recoverRAM(): Promise<void> {
+    if (global.gc) global.gc()
+    await new Promise(resolve => setTimeout(resolve, 100))
+    this.emit('recovery:ram:freed')
+  }
+
+  private async recoverStreams(): Promise<void> {
+    this.emit('recovery:streams:throttled')
+  }
+
+  stop(): void {
+    if (this.checkInterval) {
+      clearInterval(this.checkInterval)
+      this.checkInterval = null
+    }
+    this.emit('stopped')
+  }
+
+  getStatus(): Promise<HealthStatus> {
+    const status: HealthStatus = {
+      ram: this.checkRAM(),
+      streams: this.checkStreams(),
+      overall: 'healthy',
+    }
+    status.overall = this.calculateOverall(status)
+    return Promise.resolve(status)
+  }
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+import 'dotenv/config'
+import { startServer } from './api/server.js'
+
+startServer().catch(error => {
+  console.error('Failed to start server:', error)
+  process.exit(1)
+})

package/src/linter/extraction-engine.ts

@@ -0,0 +1,165 @@
+/*
+ * Layer 3: Tool Extraction Engine (Multi-Format)
+ */
+
+import type { ToolCallSource, RawToolCandidate, SecurityViolation } from './types'
+import { StructuralParser } from './structural-parser'
+
+export interface ExtractionResult {
+  candidates: RawToolCandidate[]
+  sourceHint: ToolCallSource
+  extractionErrors: string[]
+}
+
+export class ToolExtractionEngine {
+  private parser: StructuralParser
+
+  constructor() {
+    this.parser = new StructuralParser()
+  }
+
+  extract(input: string): ExtractionResult {
+    const candidates: RawToolCandidate[] = []
+    const errors: string[] = []
+    let sourceHint: ToolCallSource = this.detectSourceHint(input)
+
+    const jsonCandidates = this.extractJsonObjects(input)
+    for (const candidate of jsonCandidates) {
+      const parsed = this.tryParseJson(candidate.raw)
+      if (parsed) {
+        candidates.push({
+          source: candidate.sourceHint,
+          raw: parsed,
+          rawString: candidate.raw,
+          confidence: this.calculateJsonConfidence(parsed, candidate.sourceHint),
+        })
+      }
+    }
+
+    if (candidates.length === 0) {
+      const reactCandidates = this.extractReAct(input)
+      candidates.push(
+        ...reactCandidates.map(c => ({
+          source: 'react' as ToolCallSource,
+          raw: c.raw,
+          rawString: c.rawString,
+          confidence: 0.8,
+        }))
+      )
+    }
+
+    if (candidates.length === 0) {
+      const gemini = this.extractGemini(input)
+      if (gemini) {
+        candidates.push({
+          source: 'gemini' as ToolCallSource,
+          raw: gemini,
+          rawString: JSON.stringify(gemini),
+          confidence: 0.85,
+        })
+      }
+    }
+
+    return { candidates, sourceHint, extractionErrors: errors }
+  }
+
+  private extractJsonObjects(text: string): Array<{ raw: string; sourceHint: ToolCallSource }> {
+    const results: Array<{ raw: string; sourceHint: ToolCallSource }> = []
+    const markupCleaned = this.stripMarkup(text)
+    const jsonSpans = StructuralParser.extractJsonFromText(markupCleaned)
+
+    for (const span of jsonSpans) {
+      const sourceHint = this.detectSourceHint(span)
+      results.push({ raw: span, sourceHint })
+    }
+
+    if (results.length === 0) {
+      const funcMatch = markupCleaned.match(/call_function\s*\(\s*'(\w+)'\s*,\s*(\{[\s\S]*\})\s*\)/i)
+      if (funcMatch) {
+        results.push({ raw: `{"name":"${funcMatch[1]}","arguments":${funcMatch[2]}}`, sourceHint: 'openai' })
+      }
+    }
+
+    return results
+  }
+
+  private extractReAct(text: string): Array<{ raw: Record<string, unknown>; rawString: string }> {
+    const results: Array<{ raw: Record<string, unknown>; rawString: string }> = []
+    const patterns = [
+      /Action:\s*(\w+)\s*\n?\s*Action Input:\s*(\{[\s\S]*?)(?=\n\s*\n|\n\s*Observation|\n\s*Final Answer|$)/i,
+      /Action:\s*(\w+)\s+Action Input:\s*(\{[\s\S]*)/i,
+      /\*\*Action\*\*:\s*(\w+)\s*\n?\s*\*\*Action Input\*\*:\s*(\{[\s\S]*?)(?=\n\s*\n|\n\s*Observation|\n\s*Final Answer|$)/i,
+    ]
+
+    for (const pattern of patterns) {
+      const match = text.match(pattern)
+      if (match) {
+        let actionInputStr = match[2].trim()
+        actionInputStr = actionInputStr.replace(/\n\s*Observation.*$/is, '').trim()
+        results.push({
+          raw: { name: match[1], arguments: this.safeParse(actionInputStr) || {} },
+          rawString: match[0],
+        })
+        break
+      }
+    }
+
+    return results
+  }
+
+  private extractGemini(text: string): Record<string, unknown> | null {
+    const patterns = [
+      /functionCall\s*[:=]\s*\{\s*name\s*[:=]\s*['"]([^'"]+)['"]\s*,\s*args\s*[:=]\s*(\{[\s\S]*\})\s*\}/i,
+      /"functionCall"\s*:\s*\{\s*"name"\s*:\s*"([^"]+)"\s*,\s*"args"\s*:\s*(\{[\s\S]*?\})\s*\}/i,
+    ]
+    for (const pattern of patterns) {
+      const match = text.match(pattern)
+      if (match) return { name: match[1], arguments: this.safeParse(match[2]) || {} }
+    }
+    return null
+  }
+
+  private stripMarkup(text: string): string {
+    return text
+      .replace(/```json\s*/gi, '')
+      .replace(/```\s*/gi, '')
+      .replace(/<function_calls>/gi, '')
+      .replace(/<\/function_calls>/gi, '')
+      .trim()
+  }
+
+  private detectSourceHint(text: string): ToolCallSource {
+    const t = this.stripMarkup(text)
+    if (/\btool_use\b/.test(t) || /type:\s*['"]?tool_use/i.test(t)) return 'claude'
+    if (/\bfunctionCall\b/.test(t) || /"functionCall"/.test(t)) return 'gemini'
+    if (/\barguments\b/.test(t) && /\bname\b/.test(t)) return 'openai'
+    if (/Action:\s*\w+\s*\n?Action Input:/i.test(t)) return 'react'
+    return 'unknown'
+  }
+
+  private tryParseJson(raw: string): Record<string, unknown> | null {
+    try { return JSON.parse(raw) } catch {
+      const result = this.parser.parse(raw, 'unknown')
+      return (result.ast?.value as Record<string, unknown>) ?? null
+    }
+  }
+
+  private safeParse(str: string): Record<string, unknown> | null {
+    try { return JSON.parse(str) } catch {
+      const result = this.parser.parse(str, 'unknown')
+      return (result.ast?.value as Record<string, unknown>) ?? null
+    }
+  }
+
+  private calculateJsonConfidence(parsed: Record<string, unknown>, source: ToolCallSource): number {
+    let conf = 0.5
+    if (parsed.name) conf += 0.15
+    if (parsed.arguments && typeof parsed.arguments === 'object') conf += 0.15
+    if (parsed.input && typeof parsed.input === 'object') conf += 0.1
+    if (parsed.tool) conf += 0.1
+    if (parsed.args && typeof parsed.args === 'object') conf += 0.1
+    if (typeof parsed.arguments === 'string') conf -= 0.2
+    if (typeof parsed.input === 'string') conf -= 0.2
+    return Math.min(0.95, Math.max(0.3, conf))
+  }
+}