synapse-gateway 2.0.0

package/src/lib/benchmark/index.ts

@@ -0,0 +1,137 @@
+import { db } from '../db'
+import { modelBenchmarks } from '../db/schema'
+import { eq, desc, sql } from 'drizzle-orm'
+import { logger } from '../utils/logger'
+import { v4 as uuid } from 'uuid'
+import type { NormalizedRequest, NormalizedResponse } from '../providers/types'
+
+export interface BenchmarkResult {
+  id: string
+  model: string
+  taskType: string
+  latencyMs: number | null
+  tokensUsed: number | null
+  qualityScore: number | null
+  cost: number | null
+  providerId: string | null
+  isShadow: boolean
+}
+
+export interface ModelComparison {
+  model: string
+  avgLatencyMs: number
+  avgQualityScore: number
+  avgCost: number
+  totalBenchmarks: number
+  valueScore: number
+}
+
+class BenchmarkEngine {
+  async runBenchmark(params: {
+    model: string
+    taskType: string
+    providerId?: string
+    isShadow?: boolean
+  }, request: NormalizedRequest, response: NormalizedResponse): Promise<BenchmarkResult> {
+    const latencyMs = response.latencyMs
+    const tokensUsed = response.usage.totalTokens
+    const cost = 0
+    const qualityScore = this.calculateQualityScore(request, response)
+
+    const result: BenchmarkResult = {
+      id: uuid(),
+      model: params.model,
+      taskType: params.taskType,
+      latencyMs,
+      tokensUsed,
+      qualityScore,
+      cost,
+      providerId: params.providerId || null,
+      isShadow: params.isShadow ?? false,
+    }
+
+    try {
+      await db.insert(modelBenchmarks).values({
+        id: result.id,
+        model: result.model,
+        taskType: result.taskType,
+        latencyMs: result.latencyMs ?? null,
+        tokensUsed: result.tokensUsed ?? null,
+        qualityScore: result.qualityScore ?? null,
+        cost: result.cost ?? null,
+        providerId: result.providerId,
+        isShadow: result.isShadow,
+      })
+    } catch (err) {
+      logger.warn({ error: (err as Error).message }, 'Failed to save benchmark')
+    }
+
+    return result
+  }
+
+  private calculateQualityScore(request: NormalizedRequest, response: NormalizedResponse): number {
+    let score = 0.5
+    const content = response.choices[0]?.message?.content || ''
+
+    if (content.length > 50) score += 0.1
+    if (content.length > 200) score += 0.1
+    if (!content.includes('I cannot') && !content.includes('I\'m unable')) score += 0.1
+    if (content.includes('```')) score += 0.05
+    if (response.usage.totalTokens < request.messages.reduce((s, m) => s + m.content.length, 0) / 2) score += 0.05
+
+    if (response.latencyMs < 1000) score += 0.05
+    if (response.latencyMs < 500) score += 0.05
+
+    return Math.min(score, 1.0)
+  }
+
+  async compareModels(taskType?: string): Promise<ModelComparison[]> {
+    try {
+      const filter = taskType
+        ? sql`${modelBenchmarks.taskType} = ${taskType}`
+        : sql`1=1`
+
+      const rows = await db.select({
+        model: modelBenchmarks.model,
+        avgLatency: sql<number>`coalesce(avg(${modelBenchmarks.latencyMs}), 0)`,
+        avgQuality: sql<number>`coalesce(avg(${modelBenchmarks.qualityScore}), 0)`,
+        avgCost: sql<number>`coalesce(avg(${modelBenchmarks.cost}), 0)`,
+        count: sql<number>`count(*)`,
+      }).from(modelBenchmarks).where(filter).groupBy(modelBenchmarks.model)
+
+      return rows.map((r) => ({
+        model: r.model,
+        avgLatencyMs: Math.round(Number(r.avgLatency)),
+        avgQualityScore: Number(Number(r.avgQuality).toFixed(2)),
+        avgCost: Number(Number(r.avgCost).toFixed(4)),
+        totalBenchmarks: r.count,
+        valueScore: r.count > 0 ? Number(r.avgQuality) / (Number(r.avgCost) + 0.001) : 0,
+      })).sort((a, b) => b.avgQualityScore - a.avgQualityScore)
+    } catch {
+      return []
+    }
+  }
+
+  async getRecentBenchmarks(limit = 50): Promise<BenchmarkResult[]> {
+    try {
+      const rows = await db.select().from(modelBenchmarks)
+        .orderBy(desc(modelBenchmarks.createdAt))
+        .limit(limit)
+      return rows.map((r) => ({
+        id: r.id,
+        model: r.model,
+        taskType: r.taskType,
+        latencyMs: r.latencyMs,
+        tokensUsed: r.tokensUsed,
+        qualityScore: r.qualityScore ? Number(r.qualityScore) : null,
+        cost: r.cost ? Number(r.cost) : null,
+        providerId: r.providerId,
+        isShadow: !!r.isShadow,
+      }))
+    } catch {
+      return []
+    }
+  }
+}
+
+export const benchmarkEngine = new BenchmarkEngine()

package/src/lib/bootstrap.ts

@@ -0,0 +1,122 @@
+import { registry } from './providers/registry'
+import { OpenAIAdapter } from './providers/api-key/openai'
+import { AnthropicAdapter } from './providers/api-key/anthropic'
+import { DeepSeekAdapter } from './providers/api-key/deepseek'
+import { OpenRouterAdapter } from './providers/api-key/openrouter'
+import { GeminiAdapter } from './providers/api-key/gemini'
+import { migrate } from './db/migrate'
+import { experienceDistiller } from './distiller'
+import { healthChecker } from './health'
+import { logger } from './utils/logger'
+import { registerTool, registerResource } from './mcp/registry'
+import { pluginManager } from './plugins/index'
+import { analytics } from './analytics'
+import { memoryStore } from './memory'
+import { semanticCacheStore } from './cache'
+import type { Plugin, PluginContext } from './plugins/index'
+
+function registerMCPTools() {
+  registerTool({
+    name: 'get_usage_stats',
+    description: 'Get usage statistics',
+    inputSchema: { type: 'object', properties: { days: { type: 'number' } } },
+    handler: async (args) => analytics.getUsageStats((args.days as number) || 7),
+  })
+  registerTool({
+    name: 'get_health_status',
+    description: 'Get provider health',
+    inputSchema: { type: 'object', properties: {} },
+    handler: async () => healthChecker.getProviderHealth(),
+  })
+  registerTool({
+    name: 'get_cache_stats',
+    description: 'Get cache statistics',
+    inputSchema: { type: 'object', properties: {} },
+    handler: async () => semanticCacheStore.getStats(),
+  })
+  registerTool({
+    name: 'search_memory',
+    description: 'Search memory',
+    inputSchema: { type: 'object', properties: { query: { type: 'string' } }, required: ['query'] },
+    handler: async (args) => memoryStore.search(args.query as string),
+  })
+  registerTool({
+    name: 'clear_cache',
+    description: 'Clear cache',
+    inputSchema: { type: 'object', properties: {} },
+    handler: async () => { await semanticCacheStore.clear(); return { success: true } },
+  })
+  registerTool({
+    name: 'trigger_distillation',
+    description: 'Run distillation',
+    inputSchema: { type: 'object', properties: {} },
+    handler: async () => experienceDistiller.run(),
+  })
+  registerResource({
+    uri: 'synapse://config',
+    name: 'Configuration',
+    description: 'Current config',
+    mimeType: 'application/json',
+    read: async () => JSON.stringify({ version: '2.0.0' }),
+  })
+  registerResource({
+    uri: 'synapse://providers',
+    name: 'Providers',
+    description: 'Provider list',
+    mimeType: 'application/json',
+    read: async () => JSON.stringify(registry.list().map((a) => ({ id: a.info.id, name: a.info.name }))),
+  })
+}
+
+function registerPlugins() {
+  pluginManager.register({
+    name: 'pii-redactor',
+    description: 'Redacts PII (SSN, email, phone)',
+    phase: 'pre_request',
+    execute: async (ctx: PluginContext) => {
+      let content = ctx.content
+      content = content.replace(/\b\d{3}[-.]?\d{2}[-.]?\d{4}\b/g, '[REDACTED]')
+      content = content.replace(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g, '[REDACTED]')
+      content = content.replace(/\b(?:\+?1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g, '[REDACTED]')
+      return { modified: content !== ctx.content, content }
+    },
+  })
+  pluginManager.register({
+    name: 'response-validator',
+    description: 'Validates response quality',
+    phase: 'post_response',
+    execute: async (ctx: PluginContext) => {
+      const valid = ctx.content.trim().length > 0
+      return { modified: false, content: ctx.content, metadata: { validation: { valid } } }
+    },
+  })
+}
+
+export async function bootstrap() {
+  logger.info('Bootstrapping Synapse...')
+
+  await migrate()
+
+  const builtInProviders = [
+    new OpenAIAdapter(),
+    new AnthropicAdapter(),
+    new GeminiAdapter(),
+    new DeepSeekAdapter(),
+    new OpenRouterAdapter(),
+  ]
+
+  for (const adapter of builtInProviders) {
+    registry.register(adapter)
+  }
+
+  logger.info({ providers: builtInProviders.length }, 'Providers registered')
+
+  registerMCPTools()
+  registerPlugins()
+  logger.info('MCP tools and plugins registered')
+
+  healthChecker.start(5 * 60 * 1000)
+  experienceDistiller.start()
+
+  logger.info('Synapse bootstrap complete')
+}

package/src/lib/cache/index.ts

@@ -0,0 +1 @@
+export { semanticCacheStore, computeQueryHash } from './semantic'

package/src/lib/cache/semantic.ts

@@ -0,0 +1,211 @@
+import { db } from '../db'
+import { semanticCache as semanticCacheTable } from '../db/schema'
+import { eq, desc, sql, and, gt } from 'drizzle-orm'
+import { logger } from '../utils/logger'
+import { v4 as uuid } from 'uuid'
+
+interface CacheEntry {
+  id: string
+  promptHash: string
+  promptText: string
+  responseText: string
+  model: string
+  inputTokens: number | null
+  outputTokens: number | null
+  similarityThreshold: number
+  hits: number
+  qualityScore: number | null
+  expiresAt: string
+  createdAt: string
+}
+
+class SemanticCache {
+  private memoryCache = new Map<string, { entry: CacheEntry; expiresAt: number }>()
+  private maxMemoryEntries = 500
+
+  async get(promptHash: string): Promise<CacheEntry | null> {
+    const memEntry = this.memoryCache.get(promptHash)
+    if (memEntry) {
+      if (Date.now() > memEntry.expiresAt) {
+        this.memoryCache.delete(promptHash)
+      } else {
+        memEntry.entry.hits++
+        return memEntry.entry
+      }
+    }
+
+    try {
+      const rows = await db.select().from(semanticCacheTable)
+        .where(and(eq(semanticCacheTable.promptHash, promptHash), gt(semanticCacheTable.expiresAt, new Date().toISOString())))
+        .limit(1)
+
+      if (rows.length === 0) return null
+
+      const row = rows[0]
+      await db.update(semanticCacheTable).set({
+        hits: sql`${semanticCacheTable.hits} + 1`,
+      }).where(eq(semanticCacheTable.id, row.id))
+
+      const entry: CacheEntry = {
+        id: row.id,
+        promptHash: row.promptHash,
+        promptText: row.promptText,
+        responseText: row.responseText,
+        model: row.model,
+        inputTokens: row.inputTokens ?? null,
+        outputTokens: row.outputTokens ?? null,
+        similarityThreshold: row.similarityThreshold ?? 0.95,
+        hits: row.hits ?? 0,
+        qualityScore: row.qualityScore ?? null,
+        expiresAt: row.expiresAt,
+        createdAt: row.createdAt,
+      }
+
+      this.setMemoryCache(promptHash, entry)
+      return entry
+    } catch {
+      return null
+    }
+  }
+
+  async set(params: {
+    promptHash: string
+    promptText: string
+    responseText: string
+    model: string
+    inputTokens?: number
+    outputTokens?: number
+    similarityThreshold?: number
+    qualityScore?: number
+    ttlHours?: number
+  }): Promise<void> {
+    const id = uuid()
+    const ttlMs = (params.ttlHours || 24) * 60 * 60 * 1000
+    const expiresAt = new Date(Date.now() + ttlMs).toISOString()
+
+    const entry: CacheEntry = {
+      id,
+      promptHash: params.promptHash,
+      promptText: params.promptText,
+      responseText: params.responseText,
+      model: params.model,
+      inputTokens: params.inputTokens ?? null,
+      outputTokens: params.outputTokens ?? null,
+      similarityThreshold: params.similarityThreshold ?? 0.95,
+      hits: 0,
+      qualityScore: params.qualityScore ?? null,
+      expiresAt,
+      createdAt: new Date().toISOString(),
+    }
+
+    this.setMemoryCache(params.promptHash, entry)
+
+    try {
+      await db.insert(semanticCacheTable).values({
+        id,
+        embedding: Buffer.alloc(0),
+        promptHash: params.promptHash,
+        promptText: params.promptText,
+        responseText: params.responseText,
+        model: params.model,
+        inputTokens: params.inputTokens ?? null,
+        outputTokens: params.outputTokens ?? null,
+        similarityThreshold: params.similarityThreshold ?? 0.95,
+        hits: 0,
+        qualityScore: params.qualityScore ?? null,
+        expiresAt,
+      })
+    } catch (err) {
+      logger.warn({ error: (err as Error).message }, 'Failed to cache response')
+    }
+  }
+
+  async invalidate(promptHash: string): Promise<void> {
+    this.memoryCache.delete(promptHash)
+    try {
+      await db.delete(semanticCacheTable).where(eq(semanticCacheTable.promptHash, promptHash))
+    } catch {
+      // ignore
+    }
+  }
+
+  async clear(): Promise<void> {
+    this.memoryCache.clear()
+    try {
+      await db.delete(semanticCacheTable)
+    } catch {
+      // ignore
+    }
+  }
+
+  async cleanup(): Promise<number> {
+    const now = new Date().toISOString()
+    let deleted = 0
+
+    try {
+      const expired = await db.select({ id: semanticCacheTable.id }).from(semanticCacheTable)
+        .where(sql`${semanticCacheTable.expiresAt} < ${now}`)
+      deleted = expired.length
+
+      if (deleted > 0) {
+        await db.delete(semanticCacheTable).where(sql`${semanticCacheTable.expiresAt} < ${now}`)
+        logger.info({ deleted }, 'Cleaned up expired cache entries')
+      }
+    } catch {
+      // ignore
+    }
+
+    for (const [key, val] of this.memoryCache) {
+      if (Date.now() > val.expiresAt) {
+        this.memoryCache.delete(key)
+      }
+    }
+
+    return deleted
+  }
+
+  async getStats() {
+    try {
+      const [stats] = await db.select({
+        total: sql<number>`count(*)`,
+        hits: sql<number>`coalesce(sum(${semanticCacheTable.hits}), 0)`,
+      }).from(semanticCacheTable)
+
+      const total = stats?.total ?? 0
+      const hits = stats?.hits ?? 0
+
+      return {
+        totalEntries: total,
+        memoryEntries: this.memoryCache.size,
+        totalHits: hits,
+        hitRate: total > 0 ? hits / total : 0,
+      }
+    } catch {
+      return {
+        totalEntries: 0,
+        memoryEntries: this.memoryCache.size,
+        totalHits: 0,
+        hitRate: 0,
+      }
+    }
+  }
+
+  private setMemoryCache(key: string, entry: CacheEntry) {
+    if (this.memoryCache.size >= this.maxMemoryEntries) {
+      const oldest = this.memoryCache.keys().next().value
+      if (oldest) this.memoryCache.delete(oldest)
+    }
+    this.memoryCache.set(key, { entry, expiresAt: new Date(entry.expiresAt).getTime() })
+  }
+}
+
+export async function computeQueryHash(query: string, model: string): Promise<string> {
+  const normalized = query.toLowerCase().trim().replace(/\s+/g, ' ')
+  const data = `${normalized}:${model}`
+  const encoder = new TextEncoder()
+  const hashBuffer = await crypto.subtle.digest('SHA-256', encoder.encode(data))
+  const hashArray = Array.from(new Uint8Array(hashBuffer))
+  return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('')
+}
+
+export const semanticCacheStore = new SemanticCache()

package/src/lib/config/defaults.ts

@@ -0,0 +1,61 @@
+import type { Config } from './schema'
+
+export const configDefaults: Config = {
+  port: 3333,
+  hostname: '127.0.0.1',
+  logLevel: 'info',
+  dataDir: '',
+  auth: {
+    initialPassword: 'changeme',
+    jwtSecret: '',
+    requireApiKey: false,
+  },
+  rtk: {
+    enabled: true,
+    compressionLevel: 'balanced',
+    filters: ['git-diff', 'grep', 'ls-tree', 'log-dump', 'smart-truncate'],
+  },
+  proxy: {
+    enabled: false,
+    type: 'socks5',
+    host: '127.0.0.1',
+    port: 9050,
+  },
+  tor: {
+    enabled: false,
+    socksPort: 9050,
+    controlPort: 9051,
+    password: '',
+  },
+  cache: {
+    enabled: true,
+    ttlMinutes: 10,
+    maxSize: '100MB',
+  },
+  fallback: {
+    maxRetries: 3,
+    timeoutMs: 30000,
+    cooldownMinutes: 5,
+  },
+  cloudSync: {
+    enabled: false,
+    url: '',
+    encryptionKey: '',
+  },
+  semanticCache: {
+    enabled: true,
+    similarityThreshold: 0.95,
+    ttlMinutes: 30,
+    maxEntries: 10000,
+    embeddingModel: 'local-minilm',
+  },
+  memory: {
+    enabled: true,
+    episodicTtlDays: 90,
+    distillationIntervalHours: 6,
+  },
+  skills: {
+    enabled: true,
+    defaultRotationStrategy: 'task_match',
+  },
+}

package/src/lib/config/index.ts

@@ -0,0 +1,72 @@
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+import { configSchema, type Config } from './schema'
+import { configDefaults } from './defaults'
+
+let cachedConfig: Config | null = null
+
+function getConfigPath(): string {
+  const dataDir = process.env.DATA_DIR || path.join(os.homedir(), '.synapse')
+  return path.join(dataDir, 'config.json')
+}
+
+function ensureDataDir(): void {
+  const dataDir = process.env.DATA_DIR || path.join(os.homedir(), '.synapse')
+  if (!fs.existsSync(dataDir)) {
+    fs.mkdirSync(dataDir, { recursive: true })
+  }
+}
+
+export function loadConfig(): Config {
+  if (cachedConfig) return cachedConfig
+
+  ensureDataDir()
+  const configPath = getConfigPath()
+
+  let rawConfig: Record<string, unknown> = {}
+  if (fs.existsSync(configPath)) {
+    try {
+      const raw = fs.readFileSync(configPath, 'utf-8')
+      rawConfig = JSON.parse(raw)
+    } catch {
+      rawConfig = {}
+    }
+  }
+
+  const merged = { ...configDefaults, ...rawConfig }
+  const parsed = configSchema.safeParse(merged)
+
+  if (!parsed.success) {
+    console.error('Config validation errors:', parsed.error.flatten())
+    cachedConfig = configDefaults
+    return cachedConfig
+  }
+
+  cachedConfig = parsed.data
+
+  if (!fs.existsSync(configPath)) {
+    saveConfig(cachedConfig)
+  }
+
+  return cachedConfig
+}
+
+export function saveConfig(config: Config): void {
+  ensureDataDir()
+  const configPath = getConfigPath()
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8')
+  cachedConfig = config
+}
+
+export function updateConfig(partial: Partial<Config>): Config {
+  const current = loadConfig()
+  const updated = { ...current, ...partial }
+  const parsed = configSchema.parse(updated)
+  saveConfig(parsed)
+  return parsed
+}
+
+export function getConfig(): Config {
+  return loadConfig()
+}

package/src/lib/config/schema.ts

@@ -0,0 +1,63 @@
+import { z } from 'zod'
+
+export const configSchema = z.object({
+  port: z.number().default(3333),
+  hostname: z.string().default('127.0.0.1'),
+  logLevel: z.enum(['debug', 'info', 'warn', 'error']).default('info'),
+  dataDir: z.string().default(''),
+  auth: z.object({
+    initialPassword: z.string().default('changeme'),
+    jwtSecret: z.string().default(''),
+    requireApiKey: z.boolean().default(false),
+  }).default({ initialPassword: 'changeme', jwtSecret: '', requireApiKey: false }),
+  rtk: z.object({
+    enabled: z.boolean().default(true),
+    compressionLevel: z.enum(['none', 'light', 'balanced', 'aggressive']).default('balanced'),
+    filters: z.array(z.string()).default(['git-diff', 'grep', 'ls-tree', 'log-dump', 'smart-truncate']),
+  }).default({ enabled: true, compressionLevel: 'balanced', filters: ['git-diff', 'grep', 'ls-tree', 'log-dump', 'smart-truncate'] }),
+  proxy: z.object({
+    enabled: z.boolean().default(false),
+    type: z.enum(['http', 'socks5']).default('socks5'),
+    host: z.string().default('127.0.0.1'),
+    port: z.number().default(9050),
+  }).default({ enabled: false, type: 'socks5', host: '127.0.0.1', port: 9050 }),
+  tor: z.object({
+    enabled: z.boolean().default(false),
+    socksPort: z.number().default(9050),
+    controlPort: z.number().default(9051),
+    password: z.string().default(''),
+  }).default({ enabled: false, socksPort: 9050, controlPort: 9051, password: '' }),
+  cache: z.object({
+    enabled: z.boolean().default(true),
+    ttlMinutes: z.number().default(10),
+    maxSize: z.string().default('100MB'),
+  }).default({ enabled: true, ttlMinutes: 10, maxSize: '100MB' }),
+  fallback: z.object({
+    maxRetries: z.number().default(3),
+    timeoutMs: z.number().default(30000),
+    cooldownMinutes: z.number().default(5),
+  }).default({ maxRetries: 3, timeoutMs: 30000, cooldownMinutes: 5 }),
+  cloudSync: z.object({
+    enabled: z.boolean().default(false),
+    url: z.string().default(''),
+    encryptionKey: z.string().default(''),
+  }).default({ enabled: false, url: '', encryptionKey: '' }),
+  semanticCache: z.object({
+    enabled: z.boolean().default(true),
+    similarityThreshold: z.number().min(0).max(1).default(0.95),
+    ttlMinutes: z.number().default(30),
+    maxEntries: z.number().default(10000),
+    embeddingModel: z.string().default('local-minilm'),
+  }).default({ enabled: true, similarityThreshold: 0.95, ttlMinutes: 30, maxEntries: 10000, embeddingModel: 'local-minilm' }),
+  memory: z.object({
+    enabled: z.boolean().default(true),
+    episodicTtlDays: z.number().default(90),
+    distillationIntervalHours: z.number().default(6),
+  }).default({ enabled: true, episodicTtlDays: 90, distillationIntervalHours: 6 }),
+  skills: z.object({
+    enabled: z.boolean().default(true),
+    defaultRotationStrategy: z.enum(['task_match', 'round_robin', 'quality_based', 'schedule', 'weighted_random']).default('task_match'),
+  }).default({ enabled: true, defaultRotationStrategy: 'task_match' }),
+})
+
+export type Config = z.infer<typeof configSchema>

package/src/lib/db/index.ts

@@ -0,0 +1,22 @@
+import Database from 'better-sqlite3'
+import { drizzle } from 'drizzle-orm/better-sqlite3'
+import * as schema from './schema'
+import path from 'path'
+import os from 'os'
+import fs from 'fs'
+
+const dataDir = process.env.DATA_DIR || path.join(os.homedir(), '.synapse')
+const dbDir = path.join(dataDir, 'db')
+const dbPath = path.join(dbDir, 'synapse.db')
+
+if (!fs.existsSync(dbDir)) {
+  fs.mkdirSync(dbDir, { recursive: true })
+}
+
+const sqlite = new Database(dbPath)
+sqlite.pragma('journal_mode = WAL')
+sqlite.pragma('foreign_keys = ON')
+sqlite.pragma('busy_timeout = 5000')
+
+export const db = drizzle(sqlite, { schema })
+export { sqlite }