synapse-gateway 2.0.0

package/src/lib/router/index.ts

@@ -0,0 +1,82 @@
+import { registry } from '../providers/registry'
+import type { NormalizedRequest, NormalizedResponse, ProviderAccount } from '../providers/types'
+import { logger } from '../utils/logger'
+
+export interface RouteResult {
+  response: NormalizedResponse
+  provider: string
+  model: string
+  fallbackUsed: boolean
+  fallbackChain?: string[]
+}
+
+export async function routeRequest(
+  req: NormalizedRequest,
+  getAccount: (providerId: string) => ProviderAccount | null
+): Promise<RouteResult> {
+  const resolved = registry.resolveModel(req.model)
+  if (!resolved) {
+    if (req.model.includes('/')) {
+      throw new Error(`No provider found for model: ${req.model}`)
+    }
+    const adapters = registry.list()
+    if (adapters.length === 0) {
+      throw new Error('No providers registered')
+    }
+    const fallbackChain: string[] = []
+    for (const adapter of adapters) {
+      const account = getAccount(adapter.info.id)
+      if (!account || !account.enabled) continue
+      try {
+        const modifiedReq = { ...req, model: req.model }
+        const response = await adapter.chatCompletion(modifiedReq, account)
+        return { response, provider: adapter.info.name, model: req.model, fallbackUsed: true, fallbackChain }
+      } catch (err) {
+        fallbackChain.push(`${adapter.info.name}: ${(err as Error).message}`)
+        logger.warn({ provider: adapter.info.name, error: (err as Error).message }, 'Provider failed, trying next')
+      }
+    }
+    throw new Error(`All providers failed: ${fallbackChain.join(' | ')}`)
+  }
+
+  const { adapter, modelName } = resolved
+  const account = getAccount(adapter.info.id)
+  if (!account || !account.enabled) {
+    throw new Error(`No enabled account for provider: ${adapter.info.name}`)
+  }
+
+  const modifiedReq = { ...req, model: modelName }
+  const response = await adapter.chatCompletion(modifiedReq, account)
+
+  return {
+    response,
+    provider: adapter.info.name,
+    model: req.model,
+    fallbackUsed: false,
+  }
+}
+
+export async function routeRequestStream(
+  req: NormalizedRequest,
+  getAccount: (providerId: string) => ProviderAccount | null
+): Promise<AsyncIterable<import('../providers/types').NormalizedChunk> & { provider: string; model: string }> {
+  const resolved = registry.resolveModel(req.model)
+  if (!resolved) {
+    throw new Error(`No provider found for model: ${req.model}`)
+  }
+
+  const { adapter, modelName } = resolved
+  const account = getAccount(adapter.info.id)
+  if (!account || !account.enabled) {
+    throw new Error(`No enabled account for provider: ${adapter.info.name}`)
+  }
+
+  const modifiedReq = { ...req, model: modelName }
+  const stream = adapter.chatCompletionStream(modifiedReq, account)
+
+  return {
+    ...stream,
+    provider: adapter.info.name,
+    model: req.model,
+  }
+}

package/src/lib/skills/forge.ts

@@ -0,0 +1,57 @@
+import { db } from '../db'
+import { skills } from '../db/schema'
+import type { SkillForgeRecipe } from './types'
+import { skillRegistry } from './registry'
+import { v4 as uuid } from 'uuid'
+
+export class SkillForge {
+  async createFromRecipe(recipe: SkillForgeRecipe): Promise<string> {
+    const systemPrompt = this.buildSystemPrompt(recipe)
+    const skillId = uuid()
+
+    await skillRegistry.createSkill({
+      id: skillId,
+      name: recipe.name,
+      description: recipe.description,
+      systemPrompt,
+      preferredModel: recipe.preferredModel,
+      enabled: true,
+      groupId: null,
+    })
+
+    return skillId
+  }
+
+  async importFromOpenClaw(data: {
+    name: string
+    description: string
+    prompt: string
+    examples?: Array<{ input: string; output: string }>
+  }): Promise<string> {
+    return this.createFromRecipe({
+      name: data.name,
+      description: data.description,
+      basePrompt: data.prompt,
+      examples: data.examples || [],
+    })
+  }
+
+  private buildSystemPrompt(recipe: SkillForgeRecipe): string {
+    let prompt = recipe.basePrompt
+
+    if (recipe.constraints && recipe.constraints.length > 0) {
+      prompt += '\n\nConstraints:\n' + recipe.constraints.map((c) => `- ${c}`).join('\n')
+    }
+
+    if (recipe.examples.length > 0) {
+      prompt += '\n\nExamples:\n'
+      for (const ex of recipe.examples) {
+        prompt += `\nInput: ${ex.input}\nOutput: ${ex.output}\n`
+      }
+    }
+
+    return prompt
+  }
+}
+
+export const skillForge = new SkillForge()

package/src/lib/skills/index.ts

@@ -0,0 +1,3 @@
+export type { Skill, SkillGroup, SkillRotationResult, SkillForgeRecipe, RotationStrategy } from './types'
+export { skillRegistry } from './registry'
+export { skillForge } from './forge'

package/src/lib/skills/registry.ts

@@ -0,0 +1,195 @@
+import { db } from '../db'
+import { skills, skillGroups } from '../db/schema'
+import { eq } from 'drizzle-orm'
+import type { Skill, SkillGroup, RotationStrategy, SkillRotationResult } from './types'
+import { logger } from '../utils/logger'
+
+class SkillRegistry {
+  private skillCache = new Map<string, Skill>()
+  private groupCache = new Map<string, SkillGroup>()
+  private loaded = false
+
+  async load() {
+    if (this.loaded) return
+
+    try {
+      const allSkills = await db.select().from(skills)
+      const allGroups = await db.select().from(skillGroups)
+
+      this.skillCache.clear()
+      this.groupCache.clear()
+
+      for (const s of allSkills) {
+        const rotationConfig = s.rotationConfig ? JSON.parse(s.rotationConfig) : {}
+        this.skillCache.set(s.id, {
+          id: s.id,
+          name: s.name,
+          description: s.description || '',
+          systemPrompt: s.systemPrompt,
+          groupId: s.groupId,
+          temperature: rotationConfig.temperature ?? undefined,
+          maxTokens: rotationConfig.maxTokens ?? undefined,
+          preferredModel: rotationConfig.preferredModel ?? undefined,
+          enabled: s.enabled,
+          metadata: { usageCount: s.usageCount, qualityScore: s.qualityScore, tags: JSON.parse(s.tags) },
+        })
+      }
+
+      for (const g of allGroups) {
+        const taskTypes: string[] = g.taskTypes ? JSON.parse(g.taskTypes) : []
+        this.groupCache.set(g.id, {
+          id: g.id,
+          name: g.name,
+          description: g.description || '',
+          skillIds: taskTypes,
+          rotationStrategy: (g.rotationStrategy as RotationStrategy) || 'round_robin',
+          enabled: g.enabled,
+        })
+      }
+
+      this.loaded = true
+      logger.info({ skills: this.skillCache.size, groups: this.groupCache.size }, 'Skills loaded')
+    } catch (err) {
+      logger.warn({ error: (err as Error).message }, 'Failed to load skills from DB, using empty registry')
+      this.loaded = true
+    }
+  }
+
+  async getSkill(id: string): Promise<Skill | null> {
+    await this.load()
+    return this.skillCache.get(id) || null
+  }
+
+  async listSkills(): Promise<Skill[]> {
+    await this.load()
+    return Array.from(this.skillCache.values())
+  }
+
+  async listEnabledSkills(): Promise<Skill[]> {
+    await this.load()
+    return Array.from(this.skillCache.values()).filter((s) => s.enabled)
+  }
+
+  async getGroup(id: string): Promise<SkillGroup | null> {
+    await this.load()
+    return this.groupCache.get(id) || null
+  }
+
+  async listGroups(): Promise<SkillGroup[]> {
+    await this.load()
+    return Array.from(this.groupCache.values())
+  }
+
+  async createSkill(skill: Skill): Promise<void> {
+    const rotationConfig: Record<string, unknown> = {}
+    if (skill.temperature !== undefined) rotationConfig.temperature = skill.temperature
+    if (skill.maxTokens !== undefined) rotationConfig.maxTokens = skill.maxTokens
+    if (skill.preferredModel !== undefined) rotationConfig.preferredModel = skill.preferredModel
+
+    await db.insert(skills).values({
+      id: skill.id,
+      name: skill.name,
+      description: skill.description,
+      systemPrompt: skill.systemPrompt,
+      groupId: skill.groupId,
+      rotationConfig: JSON.stringify(rotationConfig),
+      enabled: skill.enabled,
+    })
+    this.skillCache.set(skill.id, skill)
+  }
+
+  async createGroup(group: SkillGroup): Promise<void> {
+    await db.insert(skillGroups).values({
+      id: group.id,
+      name: group.name,
+      description: group.description,
+      taskTypes: JSON.stringify(group.skillIds),
+      rotationStrategy: group.rotationStrategy,
+      enabled: group.enabled,
+    })
+    this.groupCache.set(group.id, group)
+  }
+
+  async updateSkill(id: string, updates: Partial<Skill>): Promise<void> {
+    const existing = this.skillCache.get(id)
+    if (!existing) throw new Error(`Skill not found: ${id}`)
+
+    const updated = { ...existing, ...updates }
+    const rotationConfig: Record<string, unknown> = {}
+    if (updated.temperature !== undefined) rotationConfig.temperature = updated.temperature
+    if (updated.maxTokens !== undefined) rotationConfig.maxTokens = updated.maxTokens
+    if (updated.preferredModel !== undefined) rotationConfig.preferredModel = updated.preferredModel
+
+    await db.update(skills).set({
+      name: updated.name,
+      description: updated.description,
+      systemPrompt: updated.systemPrompt,
+      groupId: updated.groupId,
+      rotationConfig: JSON.stringify(rotationConfig),
+      enabled: updated.enabled,
+    }).where(eq(skills.id, id))
+    this.skillCache.set(id, updated)
+  }
+
+  async deleteSkill(id: string): Promise<void> {
+    await db.delete(skills).where(eq(skills.id, id))
+    this.skillCache.delete(id)
+  }
+
+  async rotate(groupId: string, taskType?: string): Promise<SkillRotationResult> {
+    await this.load()
+    const group = this.groupCache.get(groupId)
+    if (!group) throw new Error(`Group not found: ${groupId}`)
+    if (!group.enabled) throw new Error(`Group "${group.name}" is disabled`)
+
+    const enabledSkills = group.skillIds
+      .map((sid) => this.skillCache.get(sid))
+      .filter((s): s is Skill => !!s && s.enabled)
+
+    if (enabledSkills.length === 0) throw new Error(`No enabled skills in group "${group.name}"`)
+    if (enabledSkills.length === 1) {
+      return { skill: enabledSkills[0], group, strategy: group.rotationStrategy, confidence: 1 }
+    }
+
+    const selected = this.applyStrategy(enabledSkills, group.rotationStrategy, taskType)
+    return { skill: selected, group, strategy: group.rotationStrategy, confidence: 0.8 }
+  }
+
+  private applyStrategy(candidates: Skill[], strategy: RotationStrategy, taskType?: string): Skill {
+    switch (strategy) {
+      case 'round_robin': {
+        const idx = Date.now() % candidates.length
+        return candidates[idx]
+      }
+      case 'quality_based':
+        return candidates[0]
+      case 'weighted_random': {
+        return candidates[Math.floor(Math.random() * candidates.length)]
+      }
+      case 'task_match': {
+        if (taskType) {
+          const match = candidates.find((s) =>
+            s.name.toLowerCase().includes(taskType.toLowerCase()) ||
+            s.description.toLowerCase().includes(taskType.toLowerCase())
+          )
+          if (match) return match
+        }
+        return candidates[0]
+      }
+      case 'schedule': {
+        const idx = Math.floor(Date.now() / 3600000) % candidates.length
+        return candidates[idx]
+      }
+      default:
+        return candidates[0]
+    }
+  }
+
+  invalidate() {
+    this.loaded = false
+    this.skillCache.clear()
+    this.groupCache.clear()
+  }
+}
+
+export const skillRegistry = new SkillRegistry()

package/src/lib/skills/types.ts

@@ -0,0 +1,44 @@
+export type RotationStrategy = 'task_match' | 'round_robin' | 'quality_based' | 'schedule' | 'weighted_random'
+
+export interface Skill {
+  id: string
+  name: string
+  description: string
+  systemPrompt: string
+  groupId: string | null
+  temperature?: number
+  maxTokens?: number
+  preferredModel?: string
+  enabled: boolean
+  metadata?: Record<string, unknown>
+}
+
+export interface SkillGroup {
+  id: string
+  name: string
+  description: string
+  skillIds: string[]
+  rotationStrategy: RotationStrategy
+  enabled: boolean
+  schedule?: {
+    cron: string
+    timezone: string
+  }
+  weights?: Record<string, number>
+}
+
+export interface SkillRotationResult {
+  skill: Skill
+  group: SkillGroup | null
+  strategy: RotationStrategy
+  confidence: number
+}
+
+export interface SkillForgeRecipe {
+  name: string
+  description: string
+  basePrompt: string
+  examples: Array<{ input: string; output: string }>
+  constraints?: string[]
+  preferredModel?: string
+}

package/src/lib/squeezer/index.ts

@@ -0,0 +1,158 @@
+export type CompressionLevel = 'none' | 'light' | 'balanced' | 'aggressive'
+
+export interface SqueezeResult {
+  originalTokens: number
+  squeezedTokens: number
+  savingsPercent: number
+  level: CompressionLevel
+  filters: string[]
+}
+
+export interface SqueezeContext {
+  content: string
+  contentType: 'code' | 'text' | 'mixed'
+  contextWindow: number
+  usedTokens: number
+  targetTokens?: number
+}
+
+const CODE_PATTERNS = /(?:function|class|const |let |var |import |export |def |async |return |=>|```|\{|\}|\[|\])/
+const COMMENT_PATTERNS = /(?:\/\/.*$|\/\*[\s\S]*?\*\/|#.*$)/gm
+const WHITESPACE_MULTI = /\n{3,}/g
+const TRAILING_WS = /[ \t]+$/gm
+const EMPTY_LINES = /^\s*\n/gm
+const CONSOLE_LOG = /console\.(log|debug|info|warn|error)\([^)]*\);?\n?/g
+const TYPE_IMPORTS = /^import\s+type\s+.*$;\s*$/gm
+const EMPTY_BLOCKS = /\{\s*\}/g
+
+function classifyContent(content: string): 'code' | 'text' | 'mixed' {
+  const lines = content.split('\n')
+  let codeLines = 0
+  let textLines = 0
+
+  for (const line of lines) {
+    if (CODE_PATTERNS.test(line)) codeLines++
+    else if (line.trim()) textLines++
+  }
+
+  if (codeLines > textLines * 2) return 'code'
+  if (textLines > codeLines * 2) return 'text'
+  return 'mixed'
+}
+
+function estimateTokens(text: string): number {
+  return Math.ceil(text.length / 4)
+}
+
+function removeComments(content: string): string {
+  return content.replace(COMMENT_PATTERNS, '')
+}
+
+function collapseWhitespace(content: string): string {
+  return content
+    .replace(TRAILING_WS, '')
+    .replace(WHITESPACE_MULTI, '\n\n')
+}
+
+function removeConsoleLogs(content: string): string {
+  return content.replace(CONSOLE_LOG, '')
+}
+
+function removeTypeImports(content: string): string {
+  return content.replace(TYPE_IMPORTS, '')
+}
+
+function collapseEmptyBlocks(content: string): string {
+  return content.replace(EMPTY_BLOCKS, '{}')
+}
+
+function removeEmptyLines(content: string): string {
+  return content.replace(EMPTY_LINES, '')
+}
+
+function smartTruncate(content: string, targetTokens: number): string {
+  const currentTokens = estimateTokens(content)
+  if (currentTokens <= targetTokens) return content
+
+  const ratio = targetTokens / currentTokens
+  const targetChars = Math.floor(content.length * ratio)
+
+  const lines = content.split('\n')
+  const result: string[] = []
+  let charCount = 0
+
+  for (const line of lines) {
+    if (charCount + line.length > targetChars) break
+    result.push(line)
+    charCount += line.length + 1
+  }
+
+  return result.join('\n')
+}
+
+export function squeeze(ctx: SqueezeContext, level: CompressionLevel = 'balanced'): SqueezeResult {
+  const originalTokens = estimateTokens(ctx.content)
+  if (level === 'none') {
+    return { originalTokens, squeezedTokens: originalTokens, savingsPercent: 0, level: 'none', filters: [] }
+  }
+
+  let content = ctx.content
+  const contentType = classifyContent(content)
+  const appliedFilters: string[] = []
+
+  if (level === 'light') {
+    content = collapseWhitespace(content)
+    appliedFilters.push('collapse_whitespace')
+  }
+
+  if (level === 'balanced' || level === 'aggressive') {
+    content = collapseWhitespace(content)
+    appliedFilters.push('collapse_whitespace')
+
+    if (contentType === 'code' || contentType === 'mixed') {
+      content = removeComments(content)
+      appliedFilters.push('remove_comments')
+
+      content = removeConsoleLogs(content)
+      appliedFilters.push('remove_console_logs')
+    }
+
+    if (level === 'balanced') {
+      content = collapseEmptyBlocks(content)
+      appliedFilters.push('collapse_empty_blocks')
+    }
+  }
+
+  if (level === 'aggressive') {
+    if (contentType === 'code' || contentType === 'mixed') {
+      content = removeTypeImports(content)
+      appliedFilters.push('remove_type_imports')
+
+      content = removeEmptyLines(content)
+      appliedFilters.push('remove_empty_lines')
+    }
+
+    const contextRemaining = ctx.contextWindow - ctx.usedTokens
+    const targetTokens = Math.min(
+      ctx.targetTokens || contextRemaining,
+      contextRemaining,
+    )
+
+    if (estimateTokens(content) > targetTokens) {
+      content = smartTruncate(content, targetTokens)
+      appliedFilters.push('smart_truncate')
+    }
+  }
+
+  const squeezedTokens = estimateTokens(content)
+  const savingsPercent = originalTokens > 0 ? ((originalTokens - squeezedTokens) / originalTokens) * 100 : 0
+
+  return { originalTokens, squeezedTokens, savingsPercent, level, filters: appliedFilters }
+}
+
+export function selectCompressionLevel(contextFillRatio: number): CompressionLevel {
+  if (contextFillRatio < 0.5) return 'none'
+  if (contextFillRatio < 0.7) return 'light'
+  if (contextFillRatio < 0.85) return 'balanced'
+  return 'aggressive'
+}

package/src/lib/utils/cn.ts

@@ -0,0 +1,6 @@
+import { type ClassValue, clsx } from 'clsx'
+import { twMerge } from 'tailwind-merge'
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}

package/src/lib/utils/logger.ts

@@ -0,0 +1,16 @@
+import pino from 'pino'
+import { getConfig } from '../config'
+
+const config = getConfig()
+
+export const logger = pino({
+  level: config.logLevel || 'info',
+  transport: {
+    target: 'pino/file',
+    options: { destination: 1 },
+  },
+  formatters: {
+    level: (label) => ({ level: label }),
+  },
+  timestamp: pino.stdTimeFunctions.isoTime,
+})

package/src/middleware.ts

@@ -0,0 +1,60 @@
+import { NextResponse } from 'next/server'
+import type { NextRequest } from 'next/server'
+
+const rateLimitMap = new Map<string, { count: number; resetAt: number }>()
+const WINDOW_MS = 60_000
+const MAX_REQUESTS = 100
+
+export function middleware(request: NextRequest) {
+  if (request.nextUrl.pathname.startsWith('/api/')) {
+    return handleApiMiddleware(request)
+  }
+  return NextResponse.next()
+}
+
+function handleApiMiddleware(request: NextRequest) {
+  const headers = new Headers()
+
+  headers.set('Access-Control-Allow-Origin', '*')
+  headers.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS')
+  headers.set('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-API-Key')
+  headers.set('Access-Control-Max-Age', '86400')
+
+  if (request.method === 'OPTIONS') {
+    return new NextResponse(null, { status: 204, headers })
+  }
+
+  headers.set('X-Request-Id', crypto.randomUUID())
+
+  const clientIp = request.headers.get('x-forwarded-for') || request.headers.get('x-real-ip') || 'unknown'
+  const key = `${clientIp}:${request.nextUrl.pathname}`
+  const now = Date.now()
+
+  const entry = rateLimitMap.get(key)
+  if (!entry || now > entry.resetAt) {
+    rateLimitMap.set(key, { count: 1, resetAt: now + WINDOW_MS })
+  } else {
+    entry.count++
+    if (entry.count > MAX_REQUESTS) {
+      headers.set('Retry-After', String(Math.ceil((entry.resetAt - now) / 1000)))
+      return NextResponse.json(
+        { error: { type: 'rate_limit_exceeded', message: 'Too many requests' } },
+        { status: 429, headers },
+      )
+    }
+  }
+
+  headers.set('X-RateLimit-Limit', String(MAX_REQUESTS))
+  headers.set('X-RateLimit-Remaining', String(Math.max(0, MAX_REQUESTS - (entry?.count || 1))))
+
+  const response = NextResponse.next()
+  for (const [k, v] of headers.entries()) {
+    response.headers.set(k, v)
+  }
+
+  return response
+}
+
+export const config = {
+  matcher: ['/api/:path*'],
+}

package/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    "**/*.mts"
+  ],
+  "exclude": ["node_modules"]
+}