synapse-gateway 2.0.0

package/src/lib/__tests__/namespace.test.ts

@@ -0,0 +1,102 @@
+import { describe, it, expect } from 'vitest'
+import { namespaceResolver, BUILTIN_ALIASES, TASK_TYPE_MODELS } from '../namespace'
+import type { TaskType } from '../namespace'
+
+describe('Namespace', () => {
+  describe('BUILTIN_ALIASES', () => {
+    it('has 8 built-in aliases', () => {
+      expect(BUILTIN_ALIASES).toHaveLength(8)
+    })
+
+    it('each alias has required fields', () => {
+      for (const a of BUILTIN_ALIASES) {
+        expect(a.alias).toBeTruthy()
+        expect(a.resolvesTo).toBeTruthy()
+        expect(a.description).toBeTruthy()
+        expect(a.taskTypes.length).toBeGreaterThan(0)
+      }
+    })
+  })
+
+  describe('resolve', () => {
+    it('resolves "best" to claude-sonnet-4', () => {
+      const result = namespaceResolver.resolve('best')
+      expect(result).toContain('an/claude-sonnet-4')
+    })
+
+    it('resolves "fast" to gpt-4o-mini', () => {
+      const result = namespaceResolver.resolve('fast')
+      expect(result).toContain('oa/gpt-4o-mini')
+    })
+
+    it('resolves "cheap" to deepseek-chat', () => {
+      const result = namespaceResolver.resolve('cheap')
+      expect(result).toContain('ds/deepseek-chat')
+    })
+
+    it('resolves "code" to a code model', () => {
+      const result = namespaceResolver.resolve('code')
+      expect(result.length).toBeGreaterThan(0)
+    })
+
+    it('passes through full model IDs', () => {
+      const result = namespaceResolver.resolve('oa/gpt-4o')
+      expect(result).toEqual(['oa/gpt-4o'])
+    })
+
+    it('is case-insensitive', () => {
+      const result = namespaceResolver.resolve('BEST')
+      expect(result).toContain('an/claude-sonnet-4')
+    })
+
+    it('returns single model for unknown short names', () => {
+      const result = namespaceResolver.resolve('unknown-model')
+      expect(result).toEqual(['unknown-model'])
+    })
+  })
+
+  describe('detectTaskType', () => {
+    it('detects code tasks', () => {
+      expect(namespaceResolver.detectTaskType('write a function that sorts an array')).toBe('code')
+      expect(namespaceResolver.detectTaskType('async function hello() {}')).toBe('code')
+      expect(namespaceResolver.detectTaskType('fix the bug in my code')).toBe('debug')
+    })
+
+    it('detects reasoning tasks', () => {
+      expect(namespaceResolver.detectTaskType('reason about this problem')).toBe('reason')
+      expect(namespaceResolver.detectTaskType('prove this theorem')).toBe('reason')
+    })
+
+    it('detects review tasks', () => {
+      expect(namespaceResolver.detectTaskType('review this pull request')).toBe('review')
+      expect(namespaceResolver.detectTaskType('critique my approach')).toBe('review')
+    })
+
+    it('defaults to chat', () => {
+      expect(namespaceResolver.detectTaskType('hello there')).toBe('chat')
+      expect(namespaceResolver.detectTaskType('how are you')).toBe('chat')
+    })
+  })
+
+  describe('resolveForTask', () => {
+    it('returns models for a task type', () => {
+      const models = namespaceResolver.resolveForTask('code')
+      expect(models.length).toBeGreaterThan(0)
+    })
+
+    it('defaults to chat for unknown task', () => {
+      const models = namespaceResolver.resolveForTask('chat' as TaskType)
+      expect(models).toEqual(TASK_TYPE_MODELS.chat)
+    })
+  })
+
+  describe('TASK_TYPE_MODELS', () => {
+    it('has models for every task type', () => {
+      const taskTypes: TaskType[] = ['code', 'chat', 'reason', 'review', 'debug', 'doc', 'translate', 'fast', 'creative', 'math']
+      for (const tt of taskTypes) {
+        expect(TASK_TYPE_MODELS[tt]).toBeDefined()
+        expect(TASK_TYPE_MODELS[tt].length).toBeGreaterThan(0)
+      }
+    })
+  })
+})

package/src/lib/__tests__/squeezer.test.ts

@@ -0,0 +1,93 @@
+import { describe, it, expect } from 'vitest'
+import { squeeze, selectCompressionLevel } from '../squeezer'
+import type { SqueezeContext, CompressionLevel } from '../squeezer'
+
+function makeCtx(content: string, overrides?: Partial<SqueezeContext>): SqueezeContext {
+  return {
+    content,
+    contentType: 'mixed',
+    contextWindow: 128000,
+    usedTokens: 0,
+    ...overrides,
+  }
+}
+
+describe('Token Squeezer', () => {
+  describe('squeeze', () => {
+    it('returns zero savings for "none" level', () => {
+      const result = squeeze(makeCtx('hello world'), 'none')
+      expect(result.savingsPercent).toBe(0)
+      expect(result.level).toBe('none')
+      expect(result.filters).toEqual([])
+    })
+
+    it('applies whitespace collapsing for "light" level', () => {
+      const content = 'hello\n\n\n\nworld'
+      const result = squeeze(makeCtx(content), 'light')
+      expect(result.filters).toContain('collapse_whitespace')
+      expect(result.squeezedTokens).toBeLessThanOrEqual(result.originalTokens)
+    })
+
+    it('removes comments for code content at "balanced" level', () => {
+      const content = '// this is a comment\nfunction hello() {\n  return 42;\n}\n/* block comment */'
+      const result = squeeze(makeCtx(content, { contentType: 'code' }), 'balanced')
+      expect(result.filters).toContain('collapse_whitespace')
+      expect(result.filters).toContain('remove_comments')
+      expect(result.filters).toContain('remove_console_logs')
+    })
+
+    it('removes console.log for code at "balanced" level', () => {
+      const content = 'console.log("debug");\nconsole.error("err");\nconst x = 1;'
+      const result = squeeze(makeCtx(content, { contentType: 'code' }), 'balanced')
+      expect(result.filters).toContain('remove_console_logs')
+    })
+
+    it('applies aggressive compression with truncation', () => {
+      const longContent = Array.from({ length: 1000 }, (_, i) => `// line ${i}\nconsole.log("${i}");\nimport type { T${i} } from "mod";\nconst x${i} = ${i};\n`).join('\n')
+      const result = squeeze(makeCtx(longContent, { contentType: 'code', usedTokens: 120000, targetTokens: 1000 }), 'aggressive')
+      expect(result.filters).toContain('collapse_whitespace')
+      expect(result.filters).toContain('remove_comments')
+      expect(result.filters).toContain('remove_console_logs')
+      expect(result.savingsPercent).toBeGreaterThan(0)
+    })
+
+    it('handles empty content', () => {
+      const result = squeeze(makeCtx(''), 'balanced')
+      expect(result.originalTokens).toBe(0)
+      expect(result.squeezedTokens).toBe(0)
+    })
+
+    it('calculates savings percent correctly', () => {
+      const content = '// comment\n\n\n\nconst x = 1;'
+      const result = squeeze(makeCtx(content, { contentType: 'code' }), 'balanced')
+      expect(result.savingsPercent).toBeGreaterThanOrEqual(0)
+      expect(result.savingsPercent).toBeLessThanOrEqual(100)
+    })
+  })
+
+  describe('selectCompressionLevel', () => {
+    it('returns "none" for low fill ratio', () => {
+      expect(selectCompressionLevel(0.3)).toBe('none')
+    })
+
+    it('returns "light" for moderate fill ratio', () => {
+      expect(selectCompressionLevel(0.6)).toBe('light')
+    })
+
+    it('returns "balanced" for high fill ratio', () => {
+      expect(selectCompressionLevel(0.75)).toBe('balanced')
+    })
+
+    it('returns "aggressive" for very high fill ratio', () => {
+      expect(selectCompressionLevel(0.9)).toBe('aggressive')
+    })
+
+    it('handles edge cases', () => {
+      expect(selectCompressionLevel(0)).toBe('none')
+      expect(selectCompressionLevel(0.5)).toBe('light')
+      expect(selectCompressionLevel(0.7)).toBe('balanced')
+      expect(selectCompressionLevel(0.85)).toBe('aggressive')
+      expect(selectCompressionLevel(1)).toBe('aggressive')
+    })
+  })
+})

package/src/lib/__tests__/utils.test.ts

@@ -0,0 +1,28 @@
+import { describe, it, expect } from 'vitest'
+import { cn } from '../utils/cn'
+
+describe('cn utility', () => {
+  it('merges class names', () => {
+    expect(cn('foo', 'bar')).toBe('foo bar')
+  })
+
+  it('handles conditional classes', () => {
+    expect(cn('base', false && 'hidden', 'visible')).toBe('base visible')
+  })
+
+  it('handles undefined and null', () => {
+    expect(cn('base', undefined, null, 'end')).toBe('base end')
+  })
+
+  it('merges tailwind conflicts', () => {
+    expect(cn('px-2', 'px-4')).toBe('px-4')
+  })
+
+  it('handles empty input', () => {
+    expect(cn()).toBe('')
+  })
+
+  it('handles arrays', () => {
+    expect(cn(['foo', 'bar'], 'baz')).toBe('foo bar baz')
+  })
+})

package/src/lib/analytics/index.ts

@@ -0,0 +1,187 @@
+import { db } from '../db'
+import { requestLogs, usageDaily, providerHealth } from '../db/schema'
+import { sql, desc, and, gte } from 'drizzle-orm'
+import { logger } from '../utils/logger'
+
+export interface UsageStats {
+  totalRequests: number
+  totalInputTokens: number
+  totalOutputTokens: number
+  totalTokensSaved: number
+  totalCost: number
+  totalErrors: number
+  totalFallbacks: number
+  totalCacheHits: number
+  avgLatencyMs: number
+  cacheHitRate: number
+  errorRate: number
+  fallbackRate: number
+}
+
+export interface TimeSeriesPoint {
+  date: string
+  requests: number
+  tokens: number
+  cost: number
+}
+
+class AnalyticsAggregator {
+  async getUsageStats(days = 7): Promise<UsageStats> {
+    try {
+      const since = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString().split('T')[0]
+
+      const [stats] = await db.select({
+        totalRequests: sql<number>`coalesce(sum(${usageDaily.totalRequests}), 0)`,
+        totalInputTokens: sql<number>`coalesce(sum(${usageDaily.totalInputTokens}), 0)`,
+        totalOutputTokens: sql<number>`coalesce(sum(${usageDaily.totalOutputTokens}), 0)`,
+        totalTokensSaved: sql<number>`coalesce(sum(${usageDaily.totalTokensSaved}), 0)`,
+        totalCost: sql<number>`coalesce(sum(${usageDaily.totalCost}), 0)`,
+        totalErrors: sql<number>`coalesce(sum(${usageDaily.totalErrors}), 0)`,
+        totalFallbacks: sql<number>`coalesce(sum(${usageDaily.totalFallbacks}), 0)`,
+        totalCacheHits: sql<number>`coalesce(sum(${usageDaily.totalCacheHits}), 0)`,
+      }).from(usageDaily).where(gte(usageDaily.date, since))
+
+      const total = stats?.totalRequests ?? 0
+      const hits = stats?.totalCacheHits ?? 0
+      const errors = stats?.totalErrors ?? 0
+      const fallbacks = stats?.totalFallbacks ?? 0
+
+      const [latency] = await db.select({
+        avg: sql<number>`coalesce(avg(${requestLogs.latencyMs}), 0)`,
+      }).from(requestLogs).where(sql`${requestLogs.createdAt} >= ${since}`)
+
+      return {
+        totalRequests: total,
+        totalInputTokens: stats?.totalInputTokens ?? 0,
+        totalOutputTokens: stats?.totalOutputTokens ?? 0,
+        totalTokensSaved: stats?.totalTokensSaved ?? 0,
+        totalCost: Number(stats?.totalCost ?? 0),
+        totalErrors: errors,
+        totalFallbacks: fallbacks,
+        totalCacheHits: hits,
+        avgLatencyMs: Math.round(Number(latency?.avg ?? 0)),
+        cacheHitRate: total > 0 ? hits / total : 0,
+        errorRate: total > 0 ? errors / total : 0,
+        fallbackRate: total > 0 ? fallbacks / total : 0,
+      }
+    } catch {
+      return {
+        totalRequests: 0, totalInputTokens: 0, totalOutputTokens: 0,
+        totalTokensSaved: 0, totalCost: 0, totalErrors: 0,
+        totalFallbacks: 0, totalCacheHits: 0, avgLatencyMs: 0,
+        cacheHitRate: 0, errorRate: 0, fallbackRate: 0,
+      }
+    }
+  }
+
+  async getUsageTimeSeries(days = 30): Promise<TimeSeriesPoint[]> {
+    try {
+      const since = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString().split('T')[0]
+
+      const rows = await db.select({
+        date: usageDaily.date,
+        requests: sql<number>`coalesce(sum(${usageDaily.totalRequests}), 0)`,
+        tokens: sql<number>`coalesce(sum(${usageDaily.totalInputTokens} + ${usageDaily.totalOutputTokens}), 0)`,
+        cost: sql<number>`coalesce(sum(${usageDaily.totalCost}), 0)`,
+      }).from(usageDaily).where(gte(usageDaily.date, since)).groupBy(usageDaily.date).orderBy(usageDaily.date)
+
+      return rows.map((r) => ({
+        date: r.date,
+        requests: r.requests,
+        tokens: r.tokens,
+        cost: Number(r.cost),
+      }))
+    } catch {
+      return []
+    }
+  }
+
+  async getProviderPerformance() {
+    try {
+      const health = await db.select().from(providerHealth)
+      return health.map((h) => ({
+        providerId: h.providerId,
+        status: h.status,
+        avgLatencyMs: h.avgLatencyMs,
+        p95LatencyMs: h.p95LatencyMs,
+        errorRate: h.errorRate,
+        successRate: h.successRate,
+        consecutiveFailures: h.consecutiveFailures,
+      }))
+    } catch {
+      return []
+    }
+  }
+
+  async getTopModels(limit = 10) {
+    try {
+      const rows = await db.select({
+        model: requestLogs.model,
+        count: sql<number>`count(*)`,
+        totalTokens: sql<number>`coalesce(sum(${requestLogs.inputTokens} + ${requestLogs.outputTokens}), 0)`,
+        totalCost: sql<number>`coalesce(sum(${requestLogs.cost}), 0)`,
+        avgLatency: sql<number>`coalesce(avg(${requestLogs.latencyMs}), 0)`,
+      }).from(requestLogs)
+        .groupBy(requestLogs.model)
+        .orderBy(desc(sql`count(*)`))
+        .limit(limit)
+
+      return rows.map((r) => ({
+        model: r.model,
+        requests: r.count,
+        tokens: r.totalTokens,
+        cost: Number(r.totalCost),
+        avgLatency: Math.round(Number(r.avgLatency)),
+      }))
+    } catch {
+      return []
+    }
+  }
+
+  async recordDailyUsage(data: {
+    date: string
+    providerId?: string
+    model?: string
+    requests?: number
+    inputTokens?: number
+    outputTokens?: number
+    tokensSaved?: number
+    cost?: number
+    errors?: number
+    fallbacks?: number
+    cacheHits?: number
+  }) {
+    try {
+      await db.insert(usageDaily).values({
+        id: crypto.randomUUID(),
+        date: data.date,
+        providerId: data.providerId || null,
+        model: data.model || null,
+        totalRequests: data.requests || 0,
+        totalInputTokens: data.inputTokens || 0,
+        totalOutputTokens: data.outputTokens || 0,
+        totalTokensSaved: data.tokensSaved || 0,
+        totalCost: data.cost || 0,
+        totalErrors: data.errors || 0,
+        totalFallbacks: data.fallbacks || 0,
+        totalCacheHits: data.cacheHits || 0,
+      }).onConflictDoUpdate({
+        target: [usageDaily.date, usageDaily.providerId, usageDaily.model],
+        set: {
+          totalRequests: sql`${usageDaily.totalRequests} + ${data.requests || 0}`,
+          totalInputTokens: sql`${usageDaily.totalInputTokens} + ${data.inputTokens || 0}`,
+          totalOutputTokens: sql`${usageDaily.totalOutputTokens} + ${data.outputTokens || 0}`,
+          totalTokensSaved: sql`${usageDaily.totalTokensSaved} + ${data.tokensSaved || 0}`,
+          totalCost: sql`${usageDaily.totalCost} + ${data.cost || 0}`,
+          totalErrors: sql`${usageDaily.totalErrors} + ${data.errors || 0}`,
+          totalFallbacks: sql`${usageDaily.totalFallbacks} + ${data.fallbacks || 0}`,
+          totalCacheHits: sql`${usageDaily.totalCacheHits} + ${data.cacheHits || 0}`,
+        },
+      })
+    } catch (err) {
+      logger.warn({ error: (err as Error).message }, 'Failed to record daily usage')
+    }
+  }
+}
+
+export const analytics = new AnalyticsAggregator()

package/src/lib/auth/guard.tsx

@@ -0,0 +1,71 @@
+'use client'
+
+import { useEffect, useState } from 'react'
+import { useRouter } from 'next/navigation'
+import { Zap } from 'lucide-react'
+
+export function useAuth() {
+  const [user, setUser] = useState<{ id: string; role: string; name: string } | null>(null)
+  const [loading, setLoading] = useState(true)
+  const router = useRouter()
+
+  useEffect(() => {
+    const token = localStorage.getItem('synapse_token')
+    if (!token) {
+      setLoading(false)
+      return
+    }
+
+    fetch('/api/auth/login', {
+      headers: { Authorization: `Bearer ${token}` },
+    })
+      .then((r) => {
+        if (!r.ok) throw new Error('Invalid token')
+        return r.json()
+      })
+      .then((data) => {
+        setUser(data.user)
+        setLoading(false)
+      })
+      .catch(() => {
+        localStorage.removeItem('synapse_token')
+        localStorage.removeItem('synapse_user')
+        setLoading(false)
+      })
+  }, [router])
+
+  function logout() {
+    localStorage.removeItem('synapse_token')
+    localStorage.removeItem('synapse_user')
+    setUser(null)
+    router.push('/login')
+  }
+
+  return { user, loading, logout }
+}
+
+export function AuthGuard({ children }: { children: React.ReactNode }) {
+  const { loading, user } = useAuth()
+  const router = useRouter()
+
+  useEffect(() => {
+    if (!loading && !user) {
+      router.push('/login')
+    }
+  }, [loading, user, router])
+
+  if (loading) {
+    return (
+      <div className="min-h-screen flex items-center justify-center bg-background">
+        <div className="flex items-center gap-2 text-muted-foreground">
+          <Zap className="h-5 w-5 text-primary animate-pulse" />
+          <span className="text-sm">Loading...</span>
+        </div>
+      </div>
+    )
+  }
+
+  if (!user) return null
+
+  return <>{children}</>
+}

package/src/lib/auth/index.ts

@@ -0,0 +1,105 @@
+import { SignJWT, jwtVerify } from 'jose'
+import { db } from '../db'
+import { apiKeys } from '../db/schema'
+import { eq } from 'drizzle-orm'
+import { createHash, randomBytes } from 'crypto'
+
+const JWT_ALG = 'HS256'
+
+function getSecret(): Uint8Array {
+  const secret = process.env.JWT_SECRET || 'synapse-default-secret-change-me-in-production'
+  return new TextEncoder().encode(secret)
+}
+
+export async function signJwt(payload: {
+  sub: string
+  role: string
+  name?: string
+}): Promise<string> {
+  return new SignJWT({ role: payload.role, name: payload.name })
+    .setProtectedHeader({ alg: JWT_ALG })
+    .setSubject(payload.sub)
+    .setIssuedAt()
+    .setExpirationTime('7d')
+    .setIssuer('synapse')
+    .sign(getSecret())
+}
+
+export async function verifyJwt(token: string): Promise<{
+  sub: string
+  role: string
+  name?: string
+} | null> {
+  try {
+    const { payload } = await jwtVerify(token, getSecret(), { issuer: 'synapse' })
+    return {
+      sub: payload.sub as string,
+      role: (payload as Record<string, unknown>).role as string,
+      name: (payload as Record<string, unknown>).name as string | undefined,
+    }
+  } catch {
+    return null
+  }
+}
+
+export async function hashApiKey(key: string): Promise<string> {
+  return createHash('sha256').update(key).digest('hex')
+}
+
+export async function generateApiKey(name: string): Promise<{ id: string; key: string }> {
+  const rawKey = `adn_${randomBytes(32).toString('hex')}`
+  const keyHash = await hashApiKey(rawKey)
+  const id = crypto.randomUUID()
+
+  await db.insert(apiKeys).values({
+    id,
+    name,
+    keyHash,
+    permissions: '{}',
+  })
+
+  return { id, key: rawKey }
+}
+
+export async function validateApiKey(key: string): Promise<{
+  valid: boolean
+  id?: string
+  name?: string
+}> {
+  if (!key) return { valid: false }
+
+  const keyHash = await hashApiKey(key)
+
+  try {
+    const rows = await db.select().from(apiKeys).where(eq(apiKeys.keyHash, keyHash)).limit(1)
+    if (rows.length === 0) return { valid: false }
+
+    await db.update(apiKeys).set({
+      lastUsedAt: new Date().toISOString(),
+    }).where(eq(apiKeys.id, rows[0].id))
+
+    return { valid: true, id: rows[0].id, name: rows[0].name }
+  } catch {
+    return { valid: false }
+  }
+}
+
+export async function listApiKeys() {
+  try {
+    const allKeys = await db.select().from(apiKeys)
+    return allKeys.map((k) => ({
+      id: k.id,
+      name: k.name,
+      keyPrefix: `adn_****${k.keyHash.slice(-4)}`,
+      createdAt: k.createdAt,
+      lastUsedAt: k.lastUsedAt,
+      requestCount: 0,
+    }))
+  } catch {
+    return []
+  }
+}
+
+export async function revokeApiKey(id: string) {
+  await db.delete(apiKeys).where(eq(apiKeys.id, id))
+}

package/src/lib/auth/middleware.ts

@@ -0,0 +1,64 @@
+import { NextResponse } from 'next/server'
+import type { NextRequest } from 'next/server'
+import { verifyJwt, validateApiKey } from '../auth'
+
+export async function authenticateRequest(request: NextRequest): Promise<{
+  authenticated: boolean
+  userId?: string
+  role?: string
+  authMethod?: 'jwt' | 'api_key' | 'none'
+}> {
+  if (request.nextUrl.pathname.startsWith('/api/v1/')) {
+    return checkGatewayAuth(request)
+  }
+
+  if (request.nextUrl.pathname.startsWith('/api/auth/')) {
+    return { authenticated: true, authMethod: 'none' }
+  }
+
+  return { authenticated: true, authMethod: 'none' }
+}
+
+async function checkGatewayAuth(request: NextRequest): Promise<{
+  authenticated: boolean
+  userId?: string
+  role?: string
+  authMethod?: 'jwt' | 'api_key' | 'none'
+}> {
+  const authHeader = request.headers.get('authorization')
+  if (authHeader?.startsWith('Bearer ')) {
+    const token = authHeader.slice(7)
+
+    if (token.startsWith('adn_')) {
+      const result = await validateApiKey(token)
+      if (result.valid) {
+        return { authenticated: true, userId: result.id, role: 'api_user', authMethod: 'api_key' }
+      }
+    }
+
+    const jwtResult = await verifyJwt(token)
+    if (jwtResult) {
+      return { authenticated: true, userId: jwtResult.sub, role: jwtResult.role, authMethod: 'jwt' }
+    }
+
+    return { authenticated: false }
+  }
+
+  const apiKeyHeader = request.headers.get('x-api-key')
+  if (apiKeyHeader) {
+    const result = await validateApiKey(apiKeyHeader)
+    if (result.valid) {
+      return { authenticated: true, userId: result.id, role: 'api_user', authMethod: 'api_key' }
+    }
+    return { authenticated: false }
+  }
+
+  return { authenticated: true, authMethod: 'none' }
+}
+
+export function unauthenticatedResponse() {
+  return NextResponse.json(
+    { error: { type: 'authentication_error', message: 'Invalid or missing authentication' } },
+    { status: 401 },
+  )
+}