synapse-gateway 2.0.0

package/src/lib/memory/store.ts

@@ -0,0 +1,215 @@
+import { db } from '../db'
+import { episodes, knowledge, proceduralRules } from '../db/schema'
+import { eq, desc, sql } from 'drizzle-orm'
+import type { MemorySearchResult, MemoryType } from './types'
+import { logger } from '../utils/logger'
+import { v4 as uuid } from 'uuid'
+
+export interface EpisodeInput {
+  eventType: string
+  model?: string
+  provider?: string
+  taskType?: string
+  inputTokens?: number
+  outputTokens?: number
+  tokensSaved?: number
+  latencyMs?: number
+  cost?: number
+  qualityScore?: number
+  outcome?: string
+  metadata?: Record<string, unknown>
+}
+
+export interface KnowledgeInput {
+  category: string
+  subject: string
+  key: string
+  value: string
+  confidence?: number
+  source?: string
+}
+
+export interface RuleInput {
+  category: string
+  condition: string
+  action: string
+  confidence?: number
+  priority?: number
+  status?: string
+}
+
+class MemoryStore {
+  async storeEpisode(ep: EpisodeInput): Promise<string> {
+    const id = uuid()
+    try {
+      await db.insert(episodes).values({
+        id,
+        timestamp: new Date().toISOString(),
+        eventType: ep.eventType,
+        model: ep.model || null,
+        provider: ep.provider || null,
+        taskType: ep.taskType || null,
+        inputTokens: ep.inputTokens ?? null,
+        outputTokens: ep.outputTokens ?? null,
+        tokensSaved: ep.tokensSaved ?? null,
+        latencyMs: ep.latencyMs ?? null,
+        cost: ep.cost ?? null,
+        qualityScore: ep.qualityScore ?? null,
+        outcome: ep.outcome || null,
+        metadata: ep.metadata ? JSON.stringify(ep.metadata) : '{}',
+      })
+    } catch (err) {
+      logger.warn({ error: (err as Error).message }, 'Failed to store episode')
+    }
+    return id
+  }
+
+  async getRecentEpisodes(limit = 50) {
+    try {
+      return await db.select().from(episodes).orderBy(desc(episodes.createdAt)).limit(limit)
+    } catch {
+      return []
+    }
+  }
+
+  async storeKnowledge(k: KnowledgeInput): Promise<string> {
+    const id = uuid()
+    try {
+      const existing = await db.select().from(knowledge)
+        .where(sql`${knowledge.category} = ${k.category} AND ${knowledge.subject} = ${k.subject} AND ${knowledge.key} = ${k.key}`)
+        .limit(1)
+
+      if (existing.length > 0) {
+        await db.update(knowledge).set({
+          value: k.value,
+          confidence: k.confidence ?? 0,
+          source: k.source || 'distilled',
+          lastUpdated: new Date().toISOString(),
+          sampleCount: sql`${knowledge.sampleCount} + 1`,
+        }).where(eq(knowledge.id, existing[0].id))
+        return existing[0].id
+      }
+
+      await db.insert(knowledge).values({
+        id,
+        category: k.category,
+        subject: k.subject,
+        key: k.key,
+        value: k.value,
+        confidence: k.confidence ?? 0,
+        source: k.source || 'distilled',
+      })
+    } catch (err) {
+      logger.warn({ error: (err as Error).message }, 'Failed to store knowledge')
+    }
+    return id
+  }
+
+  async getKnowledge(category: string, subject: string, key: string) {
+    try {
+      const rows = await db.select().from(knowledge)
+        .where(sql`${knowledge.category} = ${category} AND ${knowledge.subject} = ${subject} AND ${knowledge.key} = ${key}`)
+        .limit(1)
+      return rows[0] || null
+    } catch {
+      return null
+    }
+  }
+
+  async searchKnowledge(query: string, limit = 10) {
+    try {
+      return await db.select().from(knowledge)
+        .where(sql`${knowledge.value} LIKE ${`%${query}%`} OR ${knowledge.key} LIKE ${`%${query}%`}`)
+        .orderBy(desc(knowledge.confidence))
+        .limit(limit)
+    } catch {
+      return []
+    }
+  }
+
+  async storeRule(rule: RuleInput): Promise<string> {
+    const id = uuid()
+    try {
+      await db.insert(proceduralRules).values({
+        id,
+        category: rule.category,
+        condition: rule.condition,
+        action: rule.action,
+        confidence: rule.confidence ?? 0,
+        priority: rule.priority ?? 0,
+        status: rule.status || 'auto_generated',
+      })
+    } catch (err) {
+      logger.warn({ error: (err as Error).message }, 'Failed to store rule')
+    }
+    return id
+  }
+
+  async getApplicableRules(context: string) {
+    try {
+      const rows = await db.select().from(proceduralRules)
+        .where(sql`${proceduralRules.condition} LIKE ${`%${context}%`}`)
+        .orderBy(desc(proceduralRules.priority))
+        .limit(5)
+
+      for (const row of rows) {
+        await db.update(proceduralRules).set({
+          applyCount: sql`${proceduralRules.applyCount} + 1`,
+          lastAppliedAt: new Date().toISOString(),
+        }).where(eq(proceduralRules.id, row.id))
+      }
+
+      return rows
+    } catch {
+      return []
+    }
+  }
+
+  async search(query: string, types?: MemoryType[], limit = 20): Promise<MemorySearchResult[]> {
+    const results: MemorySearchResult[] = []
+    const searchTypes = types || ['episodic', 'semantic', 'procedural']
+
+    if (searchTypes.includes('semantic')) {
+      const items = await this.searchKnowledge(query, limit)
+      results.push(...items.map((k) => ({
+        id: k.id,
+        type: 'semantic' as MemoryType,
+        content: `${k.key}: ${k.value}`,
+        relevance: k.confidence ?? 0,
+        metadata: { category: k.category, source: k.source },
+      })))
+    }
+
+    if (searchTypes.includes('procedural')) {
+      const rules = await this.getApplicableRules(query)
+      results.push(...rules.map((r) => ({
+        id: r.id,
+        type: 'procedural' as MemoryType,
+        content: `${r.category}: ${r.condition} → ${r.action}`,
+        relevance: r.confidence ?? 0,
+        metadata: { action: r.action, priority: r.priority },
+      })))
+    }
+
+    return results.sort((a, b) => b.relevance - a.relevance).slice(0, limit)
+  }
+
+  async getStats() {
+    try {
+      const [epCount] = await db.select({ count: sql<number>`count(*)` }).from(episodes)
+      const [knCount] = await db.select({ count: sql<number>`count(*)` }).from(knowledge)
+      const [ruCount] = await db.select({ count: sql<number>`count(*)` }).from(proceduralRules)
+
+      return {
+        episodes: epCount?.count ?? 0,
+        knowledge: knCount?.count ?? 0,
+        rules: ruCount?.count ?? 0,
+        totalSize: 'N/A',
+      }
+    } catch {
+      return { episodes: 0, knowledge: 0, rules: 0, totalSize: 'N/A' }
+    }
+  }
+}
+
+export const memoryStore = new MemoryStore()

package/src/lib/memory/types.ts

@@ -0,0 +1,56 @@
+export type MemoryType = 'episodic' | 'semantic' | 'procedural'
+
+export interface EpisodicMemory {
+  id: string
+  userId?: string
+  sessionId?: string
+  input: string
+  output: string
+  model: string
+  provider: string
+  taskType?: string
+  skillId?: string
+  tokensUsed: number
+  cost: number
+  latencyMs: number
+  rating?: number
+  tags?: string[]
+  createdAt: Date
+  expiresAt?: Date
+}
+
+export interface SemanticMemory {
+  id: string
+  key: string
+  value: string
+  source: string
+  category: string
+  confidence: number
+  accessCount: number
+  lastAccessedAt: Date
+  createdAt: Date
+  updatedAt: Date
+}
+
+export interface ProceduralMemory {
+  id: string
+  name: string
+  description: string
+  rule: string
+  condition: string
+  action: string
+  priority: number
+  confidence: number
+  hitCount: number
+  enabled: boolean
+  createdAt: Date
+  updatedAt: Date
+}
+
+export interface MemorySearchResult {
+  id: string
+  type: MemoryType
+  content: string
+  relevance: number
+  metadata?: Record<string, unknown>
+}

package/src/lib/namespace/index.ts

@@ -0,0 +1,89 @@
+export type TaskType = 'code' | 'chat' | 'reason' | 'review' | 'debug' | 'doc' | 'translate' | 'fast' | 'creative' | 'math'
+
+export interface NamespaceAlias {
+  alias: string
+  resolvesTo: string
+  description: string
+  taskTypes: TaskType[]
+}
+
+export const BUILTIN_ALIASES: NamespaceAlias[] = [
+  { alias: 'best', resolvesTo: 'an/claude-sonnet-4', description: 'Best overall model', taskTypes: ['code', 'chat', 'reason'] },
+  { alias: 'fast', resolvesTo: 'oa/gpt-4o-mini', description: 'Fastest response', taskTypes: ['fast', 'chat'] },
+  { alias: 'smart', resolvesTo: 'an/claude-opus-4-7', description: 'Most capable', taskTypes: ['reason', 'code', 'review'] },
+  { alias: 'cheap', resolvesTo: 'ds/deepseek-chat', description: 'Cheapest option', taskTypes: ['chat', 'doc', 'translate'] },
+  { alias: 'code', resolvesTo: 'an/claude-sonnet-4', description: 'Best for code generation', taskTypes: ['code', 'debug', 'review'] },
+  { alias: 'reason', resolvesTo: 'oa/o3', description: 'Best for reasoning', taskTypes: ['reason', 'math'] },
+  { alias: 'creative', resolvesTo: 'an/claude-sonnet-4', description: 'Best for creative writing', taskTypes: ['creative'] },
+  { alias: 'long', resolvesTo: 'gm/gemini-2.5-pro', description: 'Best for long context (1M tokens)', taskTypes: ['chat', 'doc', 'review'] },
+]
+
+export const TASK_TYPE_MODELS: Record<TaskType, string[]> = {
+  code: ['an/claude-sonnet-4', 'oa/gpt-4o', 'ds/deepseek-chat'],
+  chat: ['oa/gpt-4o-mini', 'an/claude-haiku-3.5', 'gm/gemini-2.5-flash'],
+  reason: ['oa/o3', 'an/claude-opus-4-7', 'ds/deepseek-reasoner'],
+  review: ['an/claude-sonnet-4', 'oa/gpt-4o', 'an/claude-opus-4-7'],
+  debug: ['an/claude-sonnet-4', 'oa/gpt-4o', 'ds/deepseek-chat'],
+  doc: ['oa/gpt-4o-mini', 'an/claude-haiku-3.5', 'gm/gemini-2.5-flash'],
+  translate: ['oa/gpt-4o-mini', 'ds/deepseek-chat', 'gm/gemini-2.5-flash'],
+  fast: ['oa/gpt-4o-mini', 'an/claude-haiku-3.5', 'gm/gemini-2.5-flash'],
+  creative: ['an/claude-sonnet-4', 'oa/gpt-4o', 'gm/gemini-2.5-pro'],
+  math: ['oa/o3', 'ds/deepseek-reasoner', 'oa/o3-mini'],
+}
+
+class NamespaceResolver {
+  private aliases = new Map<string, NamespaceAlias>()
+  private customAliases = new Map<string, NamespaceAlias>()
+
+  constructor() {
+    for (const alias of BUILTIN_ALIASES) {
+      this.aliases.set(alias.alias, alias)
+    }
+  }
+
+  resolve(modelId: string): string[] {
+    const lower = modelId.toLowerCase().trim()
+
+    const builtin = this.aliases.get(lower)
+    if (builtin) return [builtin.resolvesTo]
+
+    const custom = this.customAliases.get(lower)
+    if (custom) return [custom.resolvesTo]
+
+    if (lower.includes('/')) return [modelId]
+
+    return [modelId]
+  }
+
+  resolveForTask(taskType: TaskType): string[] {
+    return TASK_TYPE_MODELS[taskType] || TASK_TYPE_MODELS.chat
+  }
+
+  detectTaskType(content: string): TaskType {
+    const lower = content.toLowerCase()
+
+    if (/(?:function|class|import |export |const |async |return |=>|```)/.test(lower)) return 'code'
+    if (/(?:explain why|reason about|prove|logical|deduce)/.test(lower)) return 'reason'
+    if (/(?:review|feedback|critique|improve)/.test(lower)) return 'review'
+    if (/(?:bug|error|fix|debug|stack trace|exception)/.test(lower)) return 'debug'
+    if (/(?:document|docs|readme|explain how|tutorial)/.test(lower)) return 'doc'
+    if (/(?:translate|traducir| Übersetzen)/.test(lower)) return 'translate'
+    if (/(?:write|story|poem|creative|imagine)/.test(lower)) return 'creative'
+    if (/(?:calcul|solve|equation|math|integral)/.test(lower)) return 'math'
+    return 'chat'
+  }
+
+  addAlias(alias: NamespaceAlias) {
+    this.customAliases.set(alias.alias, alias)
+  }
+
+  removeAlias(alias: string) {
+    this.customAliases.delete(alias)
+  }
+
+  listAliases(): NamespaceAlias[] {
+    return [...this.aliases.values(), ...this.customAliases.values()]
+  }
+}
+
+export const namespaceResolver = new NamespaceResolver()

package/src/lib/neural/features.ts

@@ -0,0 +1,74 @@
+export interface RequestFeatures {
+  hourOfDay: number
+  dayOfWeek: number
+  promptTokenCount: number
+  hasCode: boolean
+  hasTools: boolean
+  isStreaming: boolean
+  temperature: number
+  taskType: string
+  modelFamily: string
+  contextFillRatio: number
+}
+
+export interface RoutingPrediction {
+  provider: string
+  model: string
+  confidence: number
+  expectedLatencyMs: number
+  expectedCost: number
+  strategy: 'neural' | 'hybrid' | 'rule_based'
+}
+
+export interface RoutingStrategy {
+  name: string
+  select(features: RequestFeatures, candidates: RoutingCandidate[]): RoutingPrediction
+}
+
+export interface RoutingCandidate {
+  providerId: string
+  model: string
+  health: number
+  latency: number
+  cost: number
+  successRate: number
+}
+
+export function extractFeatures(request: {
+  messages?: Array<{ content: string; role: string }>
+  model?: string
+  stream?: boolean
+  temperature?: number
+  maxTokens?: number
+  tools?: unknown[]
+  taskType?: string
+}): RequestFeatures {
+  const now = new Date()
+  const content = (request.messages || []).map((m) => m.content).join(' ')
+  const estimatedTokens = Math.ceil(content.length / 4)
+
+  const hasCode = /(?:function|class|const |let |var |import |export |def |async |return |=>|```)/.test(content)
+  const hasTools = (request.tools?.length ?? 0) > 0
+
+  const modelFamily = (() => {
+    const m = (request.model || '').toLowerCase()
+    if (m.includes('gpt') || m.includes('o1') || m.includes('o3')) return 'openai'
+    if (m.includes('claude')) return 'anthropic'
+    if (m.includes('gemini')) return 'gemini'
+    if (m.includes('deepseek')) return 'deepseek'
+    return 'unknown'
+  })()
+
+  return {
+    hourOfDay: now.getHours(),
+    dayOfWeek: now.getDay(),
+    promptTokenCount: estimatedTokens,
+    hasCode,
+    hasTools,
+    isStreaming: request.stream ?? false,
+    temperature: request.temperature ?? 0.7,
+    taskType: request.taskType || (hasCode ? 'code' : 'chat'),
+    modelFamily,
+    contextFillRatio: Math.min(estimatedTokens / 128000, 1),
+  }
+}

package/src/lib/neural/index.ts

@@ -0,0 +1,85 @@
+import type { RequestFeatures, RoutingPrediction, RoutingCandidate } from './features'
+import { PriorityStrategy, LatencyStrategy, CostStrategy, RoundRobinStrategy, HybridStrategy } from './strategies'
+import { db } from '../db'
+import { routerTrainingData } from '../db/schema'
+import { sql } from 'drizzle-orm'
+import { logger } from '../utils/logger'
+import { v4 as uuid } from 'uuid'
+
+type StrategyName = 'priority' | 'latency' | 'cost' | 'round_robin' | 'hybrid'
+
+class NeuralRouter {
+  private strategies = new Map<string, PriorityStrategy | LatencyStrategy | CostStrategy | RoundRobinStrategy | HybridStrategy>()
+  private defaultStrategy: StrategyName = 'hybrid'
+
+  constructor() {
+    this.strategies.set('priority', new PriorityStrategy())
+    this.strategies.set('latency', new LatencyStrategy())
+    this.strategies.set('cost', new CostStrategy())
+    this.strategies.set('round_robin', new RoundRobinStrategy())
+    this.strategies.set('hybrid', new HybridStrategy())
+  }
+
+  route(features: RequestFeatures, candidates: RoutingCandidate[], strategy?: StrategyName): RoutingPrediction {
+    const strat = this.strategies.get(strategy || this.defaultStrategy)
+    if (!strat) {
+      return this.strategies.get('priority')!.select(features, candidates)
+    }
+    return strat.select(features, candidates)
+  }
+
+  setDefaultStrategy(name: StrategyName) {
+    if (this.strategies.has(name)) {
+      this.defaultStrategy = name
+    }
+  }
+
+  getDefaultStrategy(): StrategyName {
+    return this.defaultStrategy
+  }
+
+  async recordOutcome(data: {
+    features: RequestFeatures
+    selectedProvider: string
+    selectedModel: string
+    outcome: 'success' | 'timeout' | 'error' | 'rate_limited'
+    latencyMs?: number
+    cost?: number
+    qualityScore?: number
+  }) {
+    try {
+      await db.insert(routerTrainingData).values({
+        id: uuid(),
+        features: JSON.stringify(data.features),
+        selectedProvider: data.selectedProvider,
+        selectedModel: data.selectedModel,
+        outcome: data.outcome,
+        latencyMs: data.latencyMs ?? null,
+        cost: data.cost ?? null,
+        qualityScore: data.qualityScore ?? null,
+      })
+    } catch (err) {
+      logger.warn({ error: (err as Error).message }, 'Failed to record routing outcome')
+    }
+  }
+
+  async getAccuracyStats() {
+    try {
+      const [total] = await db.select({ count: sql<number>`count(*)` }).from(routerTrainingData)
+      const [success] = await db.select({ count: sql<number>`count(*)` }).from(routerTrainingData)
+        .where(sql`${routerTrainingData.outcome} = 'success'`)
+
+      const totalRequests = total?.count ?? 0
+      const successCount = success?.count ?? 0
+
+      return {
+        totalSamples: totalRequests,
+        accuracy: totalRequests > 0 ? successCount / totalRequests : 0,
+      }
+    } catch {
+      return { totalSamples: 0, accuracy: 0 }
+    }
+  }
+}
+
+export const neuralRouter = new NeuralRouter()

package/src/lib/neural/strategies.ts

@@ -0,0 +1,124 @@
+import type { RequestFeatures, RoutingPrediction, RoutingStrategy, RoutingCandidate } from './features'
+
+export class PriorityStrategy implements RoutingStrategy {
+  name = 'priority'
+  select(_features: RequestFeatures, candidates: RoutingCandidate[]): RoutingPrediction {
+    const sorted = [...candidates].sort((a, b) => {
+      if (a.health !== b.health) return b.health - a.health
+      return a.cost - b.cost
+    })
+    const best = sorted[0]
+    return {
+      provider: best.providerId,
+      model: best.model,
+      confidence: 0.5,
+      expectedLatencyMs: best.latency,
+      expectedCost: best.cost,
+      strategy: 'rule_based',
+    }
+  }
+}
+
+export class LatencyStrategy implements RoutingStrategy {
+  name = 'latency'
+  select(_features: RequestFeatures, candidates: RoutingCandidate[]): RoutingPrediction {
+    const healthy = candidates.filter((c) => c.health > 0.5)
+    const sorted = [...(healthy.length > 0 ? healthy : candidates)].sort((a, b) => a.latency - b.latency)
+    const best = sorted[0]
+    return {
+      provider: best.providerId,
+      model: best.model,
+      confidence: 0.6,
+      expectedLatencyMs: best.latency,
+      expectedCost: best.cost,
+      strategy: 'rule_based',
+    }
+  }
+}
+
+export class CostStrategy implements RoutingStrategy {
+  name = 'cost'
+  select(_features: RequestFeatures, candidates: RoutingCandidate[]): RoutingPrediction {
+    const healthy = candidates.filter((c) => c.health > 0.5)
+    const sorted = [...(healthy.length > 0 ? healthy : candidates)].sort((a, b) => a.cost - b.cost)
+    const best = sorted[0]
+    return {
+      provider: best.providerId,
+      model: best.model,
+      confidence: 0.6,
+      expectedLatencyMs: best.latency,
+      expectedCost: best.cost,
+      strategy: 'rule_based',
+    }
+  }
+}
+
+export class RoundRobinStrategy implements RoutingStrategy {
+  name = 'round_robin'
+  private counter = 0
+  select(_features: RequestFeatures, candidates: RoutingCandidate[]): RoutingPrediction {
+    const idx = this.counter % candidates.length
+    this.counter++
+    const pick = candidates[idx]
+    return {
+      provider: pick.providerId,
+      model: pick.model,
+      confidence: 0.4,
+      expectedLatencyMs: pick.latency,
+      expectedCost: pick.cost,
+      strategy: 'rule_based',
+    }
+  }
+}
+
+export class HybridStrategy implements RoutingStrategy {
+  name = 'hybrid'
+
+  constructor(
+    private neuralWeight = 0.6,
+    private ruleWeight = 0.4,
+  ) {}
+
+  select(features: RequestFeatures, candidates: RoutingCandidate[]): RoutingPrediction {
+    const scored = candidates.map((c) => {
+      const healthScore = c.health
+      const latencyScore = 1 - Math.min(c.latency / 5000, 1)
+      const costScore = 1 - Math.min(c.cost / 0.1, 1)
+      const successScore = c.successRate
+
+      const neuralBonus = this.getNeuralBonus(features, c)
+      const ruleScore = (healthScore * 0.3 + latencyScore * 0.3 + costScore * 0.2 + successScore * 0.2)
+      const finalScore = ruleScore * this.ruleWeight + neuralBonus * this.neuralWeight
+
+      return { candidate: c, score: finalScore }
+    })
+
+    scored.sort((a, b) => b.score - a.score)
+    const best = scored[0]
+
+    const confidence = Math.min(best.score, 0.95)
+    const strategy: 'neural' | 'hybrid' | 'rule_based' = confidence > 0.8 ? 'neural' : confidence > 0.5 ? 'hybrid' : 'rule_based'
+
+    return {
+      provider: best.candidate.providerId,
+      model: best.candidate.model,
+      confidence,
+      expectedLatencyMs: best.candidate.latency,
+      expectedCost: best.candidate.cost,
+      strategy,
+    }
+  }
+
+  private getNeuralBonus(features: RequestFeatures, candidate: RoutingCandidate): number {
+    let bonus = 0.5
+
+    if (features.hasCode && candidate.providerId.includes('anthropic')) bonus += 0.15
+    if (features.hasCode && candidate.providerId.includes('openai')) bonus += 0.1
+    if (features.taskType === 'reason' && candidate.providerId.includes('openai')) bonus += 0.15
+    if (features.contextFillRatio > 0.8 && candidate.providerId.includes('gemini')) bonus += 0.2
+    if (features.temperature < 0.3 && candidate.providerId.includes('openai')) bonus += 0.1
+    if (features.hourOfDay >= 9 && features.hourOfDay <= 17 && candidate.cost < 0.005) bonus += 0.05
+
+    return Math.min(bonus, 1)
+  }
+}