synapse-gateway 2.0.0

package/src/app/api/providers/accounts/route.ts

@@ -0,0 +1,91 @@
+import { db } from '@/lib/db'
+import { providerAccounts } from '@/lib/db/schema'
+import { eq } from 'drizzle-orm'
+
+export async function GET(request: Request) {
+  try {
+    const url = new URL(request.url)
+    const providerId = url.searchParams.get('providerId')
+    
+    const accounts = providerId
+      ? await db.select().from(providerAccounts).where(eq(providerAccounts.providerId, providerId))
+      : await db.select().from(providerAccounts)
+
+    return Response.json({
+      accounts: accounts.map((a) => ({
+        id: a.id,
+        providerId: a.providerId,
+        label: a.label,
+        enabled: a.enabled,
+        priority: a.priority,
+        hasApiKey: !!(a.authData && a.authData !== '{}'),
+        lastUsedAt: a.lastUsedAt,
+        createdAt: a.createdAt,
+      })),
+    })
+  } catch (err) {
+    return Response.json({ error: (err as Error).message }, { status: 500 })
+  }
+}
+
+export async function POST(request: Request) {
+  try {
+    const body = await request.json()
+    const { providerId, label, apiKey, enabled, priority } = body
+
+    if (!providerId || !apiKey) {
+      return Response.json({ error: 'providerId and apiKey are required' }, { status: 400 })
+    }
+
+    const id = crypto.randomUUID()
+    await db.insert(providerAccounts).values({
+      id,
+      providerId,
+      label: label || null,
+      authData: JSON.stringify({ apiKey }),
+      enabled: enabled ?? true,
+      priority: priority ?? 0,
+    })
+
+    return Response.json({ success: true, id })
+  } catch (err) {
+    return Response.json({ error: (err as Error).message }, { status: 500 })
+  }
+}
+
+export async function PUT(request: Request) {
+  try {
+    const body = await request.json()
+    const { id, label, apiKey, enabled, priority } = body
+
+    if (!id) {
+      return Response.json({ error: 'id is required' }, { status: 400 })
+    }
+
+    const updates: Record<string, unknown> = {
+      updatedAt: new Date().toISOString(),
+    }
+    if (label !== undefined) updates.label = label
+    if (apiKey !== undefined) updates.authData = JSON.stringify({ apiKey })
+    if (enabled !== undefined) updates.enabled = enabled
+    if (priority !== undefined) updates.priority = priority
+
+    await db.update(providerAccounts).set(updates).where(eq(providerAccounts.id, id))
+
+    return Response.json({ success: true })
+  } catch (err) {
+    return Response.json({ error: (err as Error).message }, { status: 500 })
+  }
+}
+
+export async function DELETE(request: Request) {
+  try {
+    const { id } = await request.json()
+    if (!id) return Response.json({ error: 'id is required' }, { status: 400 })
+
+    await db.delete(providerAccounts).where(eq(providerAccounts.id, id))
+    return Response.json({ success: true })
+  } catch (err) {
+    return Response.json({ error: (err as Error).message }, { status: 500 })
+  }
+}

package/src/app/api/providers/fetch-models/route.ts

@@ -0,0 +1,52 @@
+import { registry } from '@/lib/providers/registry'
+import { db } from '@/lib/db'
+import { models } from '@/lib/db/schema'
+import { eq } from 'drizzle-orm'
+
+export async function POST(request: Request) {
+  try {
+    const { providerId } = await request.json()
+    if (!providerId) {
+      return Response.json({ error: 'providerId is required' }, { status: 400 })
+    }
+
+    const adapters = registry.list()
+    const adapter = adapters.find((a) => a.info.id === providerId)
+    if (!adapter) {
+      return Response.json({ error: `Provider not found: ${providerId}` }, { status: 404 })
+    }
+
+    const fetchedModels = await adapter.fetchModels()
+
+    let upserted = 0
+    for (const m of fetchedModels) {
+      const modelId = m.id.includes('/') ? m.id : `${adapter.info.prefix}${m.id}`
+      try {
+        await db.insert(models).values({
+          id: modelId,
+          providerId: adapter.info.id,
+          name: m.name,
+          displayName: m.displayName || null,
+          pricingTier: m.pricingTier || null,
+          costPer1mInput: m.costPer1mInput ?? null,
+          costPer1mOutput: m.costPer1mOutput ?? null,
+          contextWindow: m.contextWindow ?? null,
+          capabilities: m.capabilities ? JSON.stringify(m.capabilities) : '[]',
+          available: m.available,
+        }).onConflictDoUpdate({
+          target: models.id,
+          set: {
+            displayName: m.displayName || null,
+            available: m.available,
+            lastCheckedAt: new Date().toISOString(),
+          },
+        })
+        upserted++
+      } catch {}
+    }
+
+    return Response.json({ success: true, fetched: fetchedModels.length, upserted })
+  } catch (err) {
+    return Response.json({ error: (err as Error).message }, { status: 500 })
+  }
+}

package/src/app/api/providers/health/route.ts

@@ -0,0 +1,10 @@
+import { healthChecker } from '@/lib/health'
+
+export async function GET() {
+  try {
+    const health = await healthChecker.getProviderHealth()
+    return Response.json({ health })
+  } catch (err) {
+    return Response.json({ error: (err as Error).message }, { status: 500 })
+  }
+}

package/src/app/api/providers/route.ts

@@ -0,0 +1,46 @@
+import { db } from '@/lib/db'
+import { providers, providerAccounts, providerHealth } from '@/lib/db/schema'
+import { eq } from 'drizzle-orm'
+
+export async function GET() {
+  try {
+    const allProviders = await db.select().from(providers)
+    const allAccounts = await db.select().from(providerAccounts)
+    const allHealth = await db.select().from(providerHealth)
+
+    const result = allProviders.map((p) => ({
+      ...p,
+      accounts: allAccounts.filter((a) => a.providerId === p.id),
+      health: allHealth.find((h) => h.providerId === p.id) || null,
+    }))
+
+    return Response.json({ providers: result })
+  } catch (err) {
+    return Response.json({ error: (err as Error).message }, { status: 500 })
+  }
+}
+
+export async function POST(request: Request) {
+  try {
+    const body = await request.json()
+    const { id, name, prefix, type, config, enabled, priority } = body
+
+    if (!id || !name || !prefix || !type) {
+      return Response.json({ error: 'id, name, prefix, type are required' }, { status: 400 })
+    }
+
+    await db.insert(providers).values({
+      id,
+      name,
+      prefix,
+      type,
+      config: config || '{}',
+      enabled: enabled ?? true,
+      priority: priority ?? 0,
+    })
+
+    return Response.json({ success: true, id })
+  } catch (err) {
+    return Response.json({ error: (err as Error).message }, { status: 500 })
+  }
+}

package/src/app/api/routes/pipeline/route.ts

@@ -0,0 +1,20 @@
+import { pipelineEngine } from '@/lib/pipeline'
+
+export async function GET() {
+  try {
+    const pipelines = await pipelineEngine.list()
+    return Response.json({ pipelines })
+  } catch (err) {
+    return Response.json({ error: (err as Error).message }, { status: 500 })
+  }
+}
+
+export async function POST(request: Request) {
+  try {
+    const body = await request.json()
+    const id = await pipelineEngine.create(body)
+    return Response.json({ success: true, id })
+  } catch (err) {
+    return Response.json({ error: (err as Error).message }, { status: 500 })
+  }
+}

package/src/app/api/settings/route.ts

@@ -0,0 +1,33 @@
+import { db } from '@/lib/db'
+import { settings } from '@/lib/db/schema'
+import { eq } from 'drizzle-orm'
+
+export async function GET() {
+  try {
+    const allSettings = await db.select().from(settings)
+    const config: Record<string, string> = {}
+    for (const s of allSettings) {
+      config[s.key] = s.value
+    }
+    return Response.json({ settings: config })
+  } catch (err) {
+    return Response.json({ error: (err as Error).message }, { status: 500 })
+  }
+}
+
+export async function PUT(request: Request) {
+  try {
+    const body = await request.json()
+    for (const [key, value] of Object.entries(body)) {
+      if (typeof value === 'string') {
+        await db.insert(settings).values({ key, value }).onConflictDoUpdate({
+          target: settings.key,
+          set: { value, updatedAt: new Date().toISOString() },
+        })
+      }
+    }
+    return Response.json({ success: true })
+  } catch (err) {
+    return Response.json({ error: (err as Error).message }, { status: 500 })
+  }
+}

package/src/app/api/skills/route.ts

@@ -0,0 +1,39 @@
+import { skillRegistry } from '@/lib/skills/registry'
+import { skillForge } from '@/lib/skills/forge'
+
+export async function GET() {
+  try {
+    const skills = await skillRegistry.listSkills()
+    const groups = await skillRegistry.listGroups()
+    return Response.json({ skills, groups })
+  } catch (err) {
+    return Response.json({ error: (err as Error).message }, { status: 500 })
+  }
+}
+
+export async function POST(request: Request) {
+  try {
+    const body = await request.json()
+
+    if (body.action === 'create') {
+      const skillId = await skillForge.createFromRecipe({
+        name: body.name,
+        description: body.description || '',
+        basePrompt: body.systemPrompt,
+        examples: body.examples || [],
+        constraints: body.constraints,
+        preferredModel: body.preferredModel,
+      })
+      return Response.json({ success: true, skillId })
+    }
+
+    if (body.action === 'import_openclaw') {
+      const skillId = await skillForge.importFromOpenClaw(body)
+      return Response.json({ success: true, skillId })
+    }
+
+    return Response.json({ error: 'Unknown action' }, { status: 400 })
+  } catch (err) {
+    return Response.json({ error: (err as Error).message }, { status: 500 })
+  }
+}

package/src/app/api/v1/chat/completions/route.ts

@@ -0,0 +1,156 @@
+import { NextResponse } from 'next/server'
+import { routeRequest, routeRequestStream } from '@/lib/router'
+import { db } from '@/lib/db'
+import { providerAccounts, requestLogs } from '@/lib/db/schema'
+import type { ProviderAccount } from '@/lib/providers/types'
+import { logger } from '@/lib/utils/logger'
+import { v4 as uuid } from 'uuid'
+
+function getCorsHeaders() {
+  return {
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+    'Access-Control-Allow-Headers': 'Content-Type, Authorization, X-API-Key',
+  }
+}
+
+export async function OPTIONS() {
+  return NextResponse.json({}, { headers: getCorsHeaders() })
+}
+
+export async function POST(request: Request) {
+  const requestId = uuid()
+  const startTime = Date.now()
+
+  try {
+    const body = await request.json()
+    const { model, messages, temperature, max_tokens, maxTokens, stream, tools } = body
+
+    if (!model || !messages || !Array.isArray(messages)) {
+      return NextResponse.json(
+        { error: { type: 'invalid_request', message: 'model and messages are required' } },
+        { status: 400, headers: getCorsHeaders() }
+      )
+    }
+
+    const normalizedReq = {
+      model: model as string,
+      messages: messages as Array<{ role: 'system' | 'user' | 'assistant' | 'tool'; content: string }>,
+      temperature: temperature as number | undefined,
+      maxTokens: (maxTokens || max_tokens) as number | undefined,
+      stream: stream as boolean | undefined,
+      tools: tools as unknown[] | undefined,
+    }
+
+    const accountCache = new Map<string, ProviderAccount | null>()
+    const getAccount = (providerId: string): ProviderAccount | null => {
+      if (!accountCache.has(providerId)) return null
+      return accountCache.get(providerId) ?? null
+    }
+
+    const allAccounts = await db.select().from(providerAccounts)
+    for (const row of allAccounts) {
+      let authData: Record<string, unknown> = {}
+      try { authData = JSON.parse(row.authData || '{}') } catch {}
+      const account: ProviderAccount = {
+        id: row.id,
+        providerId: row.providerId,
+        label: row.label || undefined,
+        authData,
+        enabled: row.enabled,
+        priority: row.priority,
+        quotaUsedTokens: row.quotaUsedTokens,
+        quotaLimitTokens: row.quotaLimitTokens ?? undefined,
+        quotaResetAt: row.quotaResetAt ? new Date(row.quotaResetAt) : undefined,
+        lastUsedAt: row.lastUsedAt ? new Date(row.lastUsedAt) : undefined,
+      }
+      accountCache.set(row.providerId, account)
+    }
+
+    if (stream) {
+      const encoder = new TextEncoder()
+      const streamResult = new ReadableStream({
+        async start(controller) {
+          try {
+            const routeStream = await routeRequestStream(normalizedReq, getAccount)
+            for await (const chunk of routeStream) {
+              const data = JSON.stringify({
+                id: chunk.id || requestId,
+                object: 'chat.completion.chunk',
+                model: routeStream.model,
+                choices: chunk.choices.map((c: { index: number; delta: Record<string, unknown>; finishReason: string | null }) => ({
+                  index: c.index,
+                  delta: c.delta,
+                  finish_reason: c.finishReason,
+                })),
+              })
+              controller.enqueue(encoder.encode(`data: ${data}\n\n`))
+            }
+            controller.enqueue(encoder.encode('data: [DONE]\n\n'))
+            controller.close()
+          } catch (err) {
+            const errorData = JSON.stringify({ error: { type: 'stream_error', message: (err as Error).message } })
+            controller.enqueue(encoder.encode(`data: ${errorData}\n\n`))
+            controller.close()
+          }
+        },
+      })
+
+      return new Response(streamResult, {
+        headers: {
+          'Content-Type': 'text/event-stream',
+          'Cache-Control': 'no-cache',
+          Connection: 'keep-alive',
+          ...getCorsHeaders(),
+        },
+      })
+    }
+
+    const result = await routeRequest(normalizedReq, getAccount)
+    const latencyMs = Date.now() - startTime
+
+    try {
+      await db.insert(requestLogs).values({
+        id: uuid(),
+        requestId,
+        model: result.model,
+        providerId: result.provider,
+        inputTokens: result.response.usage.inputTokens,
+        outputTokens: result.response.usage.outputTokens,
+        tokensSaved: 0,
+        cost: 0,
+        latencyMs,
+        statusCode: 200,
+        fallbackUsed: result.fallbackUsed,
+        cached: false,
+      })
+    } catch (logErr) {
+      logger.warn({ error: (logErr as Error).message }, 'Failed to log request')
+    }
+
+    const openaiResponse = {
+      id: result.response.id,
+      object: 'chat.completion',
+      created: Math.floor(Date.now() / 1000),
+      model: result.model,
+      choices: result.response.choices.map((c: { index: number; message: { role: string; content: string }; finishReason: string }) => ({
+        index: c.index,
+        message: { role: c.message.role, content: c.message.content },
+        finish_reason: c.finishReason,
+      })),
+      usage: {
+        prompt_tokens: result.response.usage.inputTokens,
+        completion_tokens: result.response.usage.outputTokens,
+        total_tokens: result.response.usage.totalTokens,
+      },
+    }
+
+    return NextResponse.json(openaiResponse, { headers: getCorsHeaders() })
+  } catch (err) {
+    logger.error({ error: (err as Error).message, requestId }, 'Chat completion failed')
+    return NextResponse.json(
+      { error: { type: 'server_error', message: (err as Error).message } },
+      { status: 500, headers: getCorsHeaders() }
+    )
+  }
+}

package/src/app/api/v1/models/route.ts

@@ -0,0 +1,44 @@
+import { NextResponse } from 'next/server'
+import { registry } from '@/lib/providers/registry'
+
+function getCorsHeaders() {
+  return {
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Methods': 'GET, OPTIONS',
+    'Access-Control-Allow-Headers': 'Content-Type, Authorization, X-API-Key',
+  }
+}
+
+export async function OPTIONS() {
+  return NextResponse.json({}, { headers: getCorsHeaders() })
+}
+
+export async function GET() {
+  const allModels: Array<{
+    id: string
+    object: string
+    created: number
+    owned_by: string
+  }> = []
+
+  for (const adapter of registry.list()) {
+    try {
+      const models = await adapter.fetchModels()
+      for (const model of models) {
+        allModels.push({
+          id: model.id,
+          object: 'model',
+          created: Math.floor(Date.now() / 1000),
+          owned_by: adapter.info.name,
+        })
+      }
+    } catch {
+      continue
+    }
+  }
+
+  return NextResponse.json({
+    object: 'list',
+    data: allModels,
+  }, { headers: getCorsHeaders() })
+}

package/src/app/dashboard/intelligence/loading.tsx

@@ -0,0 +1,14 @@
+import { StatsSkeleton } from '@/components/ui/skeleton'
+
+export default function IntelligenceLoading() {
+  return (
+    <div className="space-y-6">
+      <div className="h-4 w-64 animate-pulse rounded bg-muted" />
+      <StatsSkeleton />
+      <div className="grid grid-cols-1 lg:grid-cols-2 gap-4">
+        <div className="bg-card border border-border rounded-lg p-4 h-64 animate-pulse" />
+        <div className="bg-card border border-border rounded-lg p-4 h-64 animate-pulse" />
+      </div>
+    </div>
+  )
+}

package/src/app/dashboard/intelligence/page.tsx

@@ -0,0 +1,125 @@
+'use client'
+
+import { useEffect, useState } from 'react'
+import { Sparkles, Brain, TrendingUp, Lightbulb } from 'lucide-react'
+
+interface NeuralRouterData {
+  defaultStrategy: string
+  totalSamples: number
+  accuracy: number
+}
+
+interface ForensicsData {
+  recentFailures: Array<Record<string, unknown>>
+  slowRequests: Array<Record<string, unknown>>
+}
+
+export default function IntelligencePage() {
+  const [routerData, setRouterData] = useState<NeuralRouterData | null>(null)
+  const [forensicsData, setForensicsData] = useState<ForensicsData | null>(null)
+
+  useEffect(() => {
+    Promise.all([
+      fetch('/api/intelligence/neural-router').then((r) => r.json()).catch(() => null),
+      fetch('/api/intelligence/forensics').then((r) => r.json()).catch(() => null),
+    ]).then(([router, forensics]) => {
+      if (router) setRouterData(router as NeuralRouterData)
+      if (forensics) setForensicsData(forensics as ForensicsData)
+    })
+  }, [])
+
+  const metrics = [
+    { label: 'Routing Strategy', value: routerData?.defaultStrategy || '—', icon: Brain },
+    { label: 'Training Samples', value: (routerData?.totalSamples || 0).toLocaleString(), icon: TrendingUp },
+    { label: 'Router Accuracy', value: routerData ? `${(routerData.accuracy * 100).toFixed(1)}%` : '—', icon: Sparkles },
+    { label: 'Recent Failures', value: (forensicsData?.recentFailures?.length || 0).toString(), icon: Lightbulb },
+  ]
+
+  return (
+    <div className="space-y-6">
+      <p className="text-sm text-muted-foreground">Self-learning engine, neural router, and request forensics</p>
+
+      <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-4 gap-4">
+        {metrics.map((m) => (
+          <div key={m.label} className="bg-card border border-border rounded-lg p-4">
+            <div className="flex items-center justify-between mb-2">
+              <span className="text-xs text-muted-foreground uppercase tracking-wider">{m.label}</span>
+              <m.icon className="h-4 w-4 text-accent" />
+            </div>
+            <span className="text-2xl font-semibold">{m.value}</span>
+          </div>
+        ))}
+      </div>
+
+      <div className="grid grid-cols-1 lg:grid-cols-2 gap-4">
+        <div className="bg-card border border-border rounded-lg">
+          <div className="px-4 py-3 border-b border-border flex items-center justify-between">
+            <h2 className="text-sm font-medium">Neural Router</h2>
+            <button
+              onClick={async () => {
+                const strategy = routerData?.defaultStrategy === 'hybrid' ? 'priority' : 'hybrid'
+                await fetch('/api/intelligence/neural-router', {
+                  method: 'PUT',
+                  headers: { 'Content-Type': 'application/json' },
+                  body: JSON.stringify({ strategy }),
+                })
+                setRouterData((prev) => prev ? { ...prev, defaultStrategy: strategy } : null)
+              }}
+              className="text-xs px-2 py-1 border border-border rounded hover:bg-muted"
+            >
+              Toggle Strategy
+            </button>
+          </div>
+          <div className="p-4 space-y-3">
+            <div className="flex justify-between text-sm">
+              <span className="text-muted-foreground">Strategy</span>
+              <span className="font-medium capitalize">{routerData?.defaultStrategy || '—'}</span>
+            </div>
+            <div className="flex justify-between text-sm">
+              <span className="text-muted-foreground">Samples</span>
+              <span>{(routerData?.totalSamples || 0).toLocaleString()}</span>
+            </div>
+            <div className="flex justify-between text-sm">
+              <span className="text-muted-foreground">Accuracy</span>
+              <span className={routerData && routerData.accuracy > 0.8 ? 'text-primary' : 'text-yellow-500'}>
+                {routerData ? `${(routerData.accuracy * 100).toFixed(1)}%` : 'N/A'}
+              </span>
+            </div>
+            <div className="flex justify-between text-sm">
+              <span className="text-muted-foreground">Status</span>
+              <span className="text-primary flex items-center gap-1.5">
+                <span className="h-1.5 w-1.5 rounded-full bg-primary animate-pulse" />
+                Active
+              </span>
+            </div>
+          </div>
+        </div>
+
+        <div className="bg-card border border-border rounded-lg">
+          <div className="px-4 py-3 border-b border-border">
+            <h2 className="text-sm font-medium">Request Forensics</h2>
+          </div>
+          <div className="p-4 space-y-3">
+            <div className="flex justify-between text-sm">
+              <span className="text-muted-foreground">Recent Failures</span>
+              <span>{forensicsData?.recentFailures?.length || 0}</span>
+            </div>
+            <div className="flex justify-between text-sm">
+              <span className="text-muted-foreground">Slow Requests (&gt;3s)</span>
+              <span>{forensicsData?.slowRequests?.length || 0}</span>
+            </div>
+            <div className="text-xs text-muted-foreground mt-4">
+              Forensic analysis runs automatically on each request, providing root cause analysis, latency breakdowns, and optimization suggestions.
+            </div>
+            <button
+              onClick={async () => { await fetch('/api/distill', { method: 'POST' }) }}
+              className="w-full px-3 py-1.5 bg-accent/10 text-accent border border-accent/20 rounded-md text-sm hover:bg-accent/20 transition-colors"
+            >
+              Trigger Distillation Now
+            </button>
+          </div>
+        </div>
+      </div>
+    </div>
+  )
+}