synapse-gateway 2.0.0

package/src/lib/format/anthropic.ts

@@ -0,0 +1,139 @@
+import type { Message, NormalizedRequest } from '../providers/types'
+
+export interface AnthropicMessage {
+  role: 'user' | 'assistant'
+  content: string | AnthropicContentBlock[]
+}
+
+export interface AnthropicContentBlock {
+  type: 'text' | 'image' | 'tool_use' | 'tool_result'
+  text?: string
+  tool_use_id?: string
+  name?: string
+  input?: unknown
+  content?: string
+}
+
+export interface AnthropicRequest {
+  model: string
+  messages: AnthropicMessage[]
+  system?: string
+  max_tokens: number
+  temperature?: number
+  stream?: boolean
+  tools?: unknown[]
+}
+
+export function toAnthropicRequest(req: NormalizedRequest): AnthropicRequest {
+  const messages: AnthropicMessage[] = []
+  let system: string | undefined
+
+  for (const msg of req.messages) {
+    if (msg.role === 'system') {
+      system = (system ? system + '\n\n' : '') + msg.content
+      continue
+    }
+
+    const anthropicMsg: AnthropicMessage = {
+      role: msg.role === 'assistant' ? 'assistant' : 'user',
+      content: msg.content,
+    }
+
+    if (msg.role === 'assistant' && msg.toolCalls && msg.toolCalls.length > 0) {
+      anthropicMsg.content = [
+        { type: 'text', text: msg.content },
+        ...msg.toolCalls.map((tc) => ({
+          type: 'tool_use' as const,
+          id: tc.id,
+          name: tc.function.name,
+          input: JSON.parse(tc.function.arguments),
+        })),
+      ]
+    }
+
+    if (msg.role === 'tool') {
+      anthropicMsg.content = [
+        {
+          type: 'tool_result' as const,
+          tool_use_id: msg.toolCallId,
+          content: msg.content,
+        },
+      ]
+    }
+
+    messages.push(anthropicMsg)
+  }
+
+  if (messages.length === 0) {
+    messages.push({ role: 'user', content: ' ' })
+  }
+
+  if (messages[0].role !== 'user') {
+    messages.unshift({ role: 'user', content: ' ' })
+  }
+
+  let filtered = messages.filter((m) => m.role === 'user' || m.role === 'assistant')
+  const merged: AnthropicMessage[] = []
+  for (const msg of filtered) {
+    if (merged.length > 0 && merged[merged.length - 1].role === msg.role) {
+      const last = merged[merged.length - 1]
+      const lastText = typeof last.content === 'string' ? last.content : ''
+      const currText = typeof msg.content === 'string' ? msg.content : ''
+      merged[merged.length - 1] = { ...last, content: lastText + '\n' + currText }
+    } else {
+      merged.push(msg)
+    }
+  }
+
+  return {
+    model: req.model,
+    messages: merged,
+    system,
+    max_tokens: req.maxTokens || 4096,
+    temperature: req.temperature,
+    stream: req.stream,
+    tools: req.tools,
+  }
+}
+
+export function fromAnthropicResponse(data: Record<string, unknown>) {
+  const content = data.content as Array<{ type: string; text?: string }>
+  const textContent = content?.filter((c) => c.type === 'text').map((c) => c.text || '').join('') || ''
+
+  return {
+    id: data.id as string,
+    model: data.model as string,
+    choices: [
+      {
+        index: 0,
+        message: { role: 'assistant' as const, content: textContent },
+        finishReason: (data.stop_reason as string) || 'end_turn',
+      },
+    ],
+    usage: {
+      inputTokens: (data.usage as Record<string, number>)?.input_tokens || 0,
+      outputTokens: (data.usage as Record<string, number>)?.output_tokens || 0,
+      totalTokens:
+        ((data.usage as Record<string, number>)?.input_tokens || 0) +
+        ((data.usage as Record<string, number>)?.output_tokens || 0),
+    },
+  }
+}
+
+export function fromAnthropicChunk(data: Record<string, unknown>) {
+  const delta = data.delta as { type: string; text?: string; stop_reason?: string } | undefined
+  const isContent = delta?.type === 'text_delta'
+  const isStop = delta?.type === 'message_stop' || delta?.stop_reason
+
+  return {
+    id: (data.id as string) || '',
+    model: data.model as string,
+    choices: [
+      {
+        index: 0,
+        delta: isContent ? { role: 'assistant' as const, content: delta?.text || '' } : {},
+        finishReason: isStop ? (delta?.stop_reason as string) || 'end_turn' : null,
+      },
+    ],
+  }
+}

package/src/lib/format/gemini.ts

@@ -0,0 +1,130 @@
+import type { NormalizedRequest } from '../providers/types'
+
+export interface GeminiContent {
+  role: 'user' | 'model'
+  parts: GeminiPart[]
+}
+
+export interface GeminiPart {
+  text?: string
+  functionCall?: { name: string; args: Record<string, unknown> }
+  functionResponse?: { name: string; response: Record<string, unknown> }
+}
+
+export interface GeminiRequest {
+  model: string
+  contents: GeminiContent[]
+  systemInstruction?: { parts: Array<{ text: string }> }
+  generationConfig: {
+    maxOutputTokens?: number
+    temperature?: number
+  }
+  tools?: unknown[]
+}
+
+export function toGeminiRequest(req: NormalizedRequest): GeminiRequest {
+  const contents: GeminiContent[] = []
+  const systemParts: Array<{ text: string }> = []
+
+  for (const msg of req.messages) {
+    if (msg.role === 'system') {
+      systemParts.push({ text: msg.content })
+      continue
+    }
+
+    const parts: GeminiPart[] = []
+
+    if (msg.role === 'assistant' && msg.toolCalls) {
+      for (const tc of msg.toolCalls) {
+        parts.push({
+          functionCall: {
+            name: tc.function.name,
+            args: JSON.parse(tc.function.arguments),
+          },
+        })
+      }
+      if (msg.content) {
+        parts.unshift({ text: msg.content })
+      }
+    } else if (msg.role === 'tool') {
+      parts.push({
+        functionResponse: {
+          name: msg.toolCallId || '',
+          response: { content: msg.content },
+        },
+      })
+    } else {
+      parts.push({ text: msg.content })
+    }
+
+    if (parts.length > 0) {
+      contents.push({
+        role: msg.role === 'assistant' ? 'model' : 'user',
+        parts,
+      })
+    }
+  }
+
+  const merged: GeminiContent[] = []
+  for (const c of contents) {
+    if (merged.length > 0 && merged[merged.length - 1].role === c.role) {
+      merged[merged.length - 1] = { ...merged[merged.length - 1], parts: [...merged[merged.length - 1].parts, ...c.parts] }
+    } else {
+      merged.push(c)
+    }
+  }
+
+  return {
+    model: req.model,
+    contents: merged,
+    ...(systemParts.length > 0 ? { systemInstruction: { parts: systemParts } } : {}),
+    generationConfig: {
+      maxOutputTokens: req.maxTokens,
+      temperature: req.temperature,
+    },
+    tools: req.tools,
+  }
+}
+
+export function fromGeminiResponse(data: Record<string, unknown>) {
+  const candidates = data.candidates as Array<{ content: { parts: GeminiPart[] }; finishReason: string }> | undefined
+  const candidate = candidates?.[0]
+  const text = candidate?.content?.parts?.map((p) => p.text || '').join('') || ''
+
+  const usage = data.usageMetadata as { promptTokenCount: number; candidatesTokenCount: number; totalTokenCount: number } | undefined
+
+  return {
+    id: crypto.randomUUID(),
+    model: data.model as string,
+    choices: [
+      {
+        index: 0,
+        message: { role: 'assistant' as const, content: text },
+        finishReason: candidate?.finishReason || 'STOP',
+      },
+    ],
+    usage: {
+      inputTokens: usage?.promptTokenCount || 0,
+      outputTokens: usage?.candidatesTokenCount || 0,
+      totalTokens: usage?.totalTokenCount || 0,
+    },
+  }
+}
+
+export function fromGeminiChunk(data: Record<string, unknown>) {
+  const candidates = data.candidates as Array<{ content: { parts: GeminiPart[] }; finishReason: string }> | undefined
+  const candidate = candidates?.[0]
+  const text = candidate?.content?.parts?.map((p) => p.text || '').join('') || ''
+
+  return {
+    id: '',
+    model: '',
+    choices: [
+      {
+        index: 0,
+        delta: text ? { role: 'assistant' as const, content: text } : {},
+        finishReason: candidate?.finishReason === 'STOP' ? 'stop' : null,
+      },
+    ],
+  }
+}

package/src/lib/format/index.ts

@@ -0,0 +1,3 @@
+export { toAnthropicRequest, fromAnthropicResponse, fromAnthropicChunk } from './anthropic'
+export { toGeminiRequest, fromGeminiResponse, fromGeminiChunk } from './gemini'
+export { toOpenAIRequest, fromOpenAIResponse, fromOpenAIChunk } from './openai'

package/src/lib/format/openai.ts

@@ -0,0 +1,78 @@
+export interface OpenAIMessage {
+  role: 'system' | 'user' | 'assistant' | 'tool'
+  content: string | null
+  tool_call_id?: string
+  tool_calls?: Array<{
+    id: string
+    type: 'function'
+    function: { name: string; arguments: string }
+  }>
+}
+
+export interface OpenAIRequest {
+  model: string
+  messages: OpenAIMessage[]
+  temperature?: number
+  max_tokens?: number
+  stream?: boolean
+  tools?: unknown[]
+}
+
+export function toOpenAIRequest(req: import('../providers/types').NormalizedRequest): OpenAIRequest {
+  return {
+    model: req.model,
+    messages: req.messages.map((m) => ({
+      role: m.role,
+      content: m.content,
+      ...(m.toolCallId ? { tool_call_id: m.toolCallId } : {}),
+      ...(m.toolCalls ? { tool_calls: m.toolCalls } : {}),
+    })),
+    temperature: req.temperature,
+    max_tokens: req.maxTokens,
+    stream: req.stream,
+    tools: req.tools,
+  }
+}
+
+export function fromOpenAIResponse(data: Record<string, unknown>) {
+  const choices = data.choices as Array<{
+    index: number
+    message: { role: string; content: string }
+    finish_reason: string
+  }>
+
+  const usage = data.usage as { prompt_tokens: number; completion_tokens: number; total_tokens: number }
+
+  return {
+    id: data.id as string,
+    model: data.model as string,
+    choices: choices.map((c) => ({
+      index: c.index,
+      message: { role: c.message.role as 'assistant', content: c.message.content },
+      finishReason: c.finish_reason,
+    })),
+    usage: {
+      inputTokens: usage?.prompt_tokens || 0,
+      outputTokens: usage?.completion_tokens || 0,
+      totalTokens: usage?.total_tokens || 0,
+    },
+  }
+}
+
+export function fromOpenAIChunk(data: Record<string, unknown>) {
+  const choices = data.choices as Array<{
+    index: number
+    delta: { role?: string; content?: string }
+    finish_reason: string | null
+  }>
+
+  return {
+    id: data.id as string,
+    model: data.model as string,
+    choices: choices.map((c) => ({
+      index: c.index,
+      delta: c.delta.content ? { role: 'assistant' as const, content: c.delta.content } : {},
+      finishReason: c.finish_reason,
+    })),
+  }
+}

package/src/lib/health/index.ts

@@ -0,0 +1,158 @@
+import { db } from '../db'
+import { providerHealth, providers } from '../db/schema'
+import { eq } from 'drizzle-orm'
+import { registry } from '../providers/registry'
+import { logger } from '../utils/logger'
+import { v4 as uuid } from 'uuid'
+
+interface HealthCheckResult {
+  providerId: string
+  status: 'healthy' | 'degraded' | 'down' | 'disabled'
+  latencyMs: number
+  timestamp: string
+}
+
+class HealthChecker {
+  private intervalHandle: ReturnType<typeof setInterval> | null = null
+
+  start(intervalMs = 5 * 60 * 1000) {
+    if (this.intervalHandle) return
+
+    logger.info({ intervalMinutes: intervalMs / 60000 }, 'Health checker started')
+
+    this.intervalHandle = setInterval(async () => {
+      try {
+        await this.checkAll()
+      } catch (err) {
+        logger.error({ error: (err as Error).message }, 'Health check failed')
+      }
+    }, intervalMs)
+
+    setTimeout(() => this.checkAll(), 10000)
+  }
+
+  stop() {
+    if (this.intervalHandle) {
+      clearInterval(this.intervalHandle)
+      this.intervalHandle = null
+      logger.info('Health checker stopped')
+    }
+  }
+
+  async checkAll(): Promise<HealthCheckResult[]> {
+    const adapters = registry.list()
+    const results: HealthCheckResult[] = []
+
+    for (const adapter of adapters) {
+      try {
+        const result = await adapter.healthCheck()
+        await this.recordResult(adapter.info.id, result.status, result.latencyMs)
+        results.push({
+          providerId: adapter.info.id,
+          status: result.status,
+          latencyMs: result.latencyMs,
+          timestamp: new Date().toISOString(),
+        })
+      } catch (err) {
+        await this.recordResult(adapter.info.id, 'down', 0)
+        results.push({
+          providerId: adapter.info.id,
+          status: 'down',
+          latencyMs: 0,
+          timestamp: new Date().toISOString(),
+        })
+        logger.warn({ provider: adapter.info.id, error: (err as Error).message }, 'Health check failed')
+      }
+    }
+
+    return results
+  }
+
+  async checkProvider(providerId: string): Promise<HealthCheckResult | null> {
+    const adapters = registry.list()
+    const adapter = adapters.find((a) => a.info.id === providerId)
+    if (!adapter) return null
+
+    try {
+      const result = await adapter.healthCheck()
+      await this.recordResult(providerId, result.status, result.latencyMs)
+      return {
+        providerId,
+        status: result.status,
+        latencyMs: result.latencyMs,
+        timestamp: new Date().toISOString(),
+      }
+    } catch {
+      await this.recordResult(providerId, 'down', 0)
+      return { providerId, status: 'down', latencyMs: 0, timestamp: new Date().toISOString() }
+    }
+  }
+
+  private async recordResult(providerId: string, status: 'healthy' | 'degraded' | 'down' | 'disabled', latencyMs: number) {
+    try {
+      const existing = await db.select().from(providerHealth)
+        .where(eq(providerHealth.providerId, providerId)).limit(1)
+
+      const now = new Date().toISOString()
+
+      if (existing.length > 0) {
+        const row = existing[0]
+        const consecutiveFailures = status === 'down'
+          ? (row.consecutiveFailures || 0) + 1
+          : 0
+
+        const totalChecks = (row.successRate || 0) * 100 + 1
+        const newSuccessRate = status === 'healthy'
+          ? ((row.successRate || 0) * 100 + 1) / totalChecks
+          : (row.successRate || 0) * 100 / totalChecks
+
+        const totalLatencyChecks = 100
+        const newAvgLatency = Math.round(
+          ((row.avgLatencyMs || 0) * (totalLatencyChecks - 1) + latencyMs) / totalLatencyChecks
+        )
+
+        await db.update(providerHealth).set({
+          status: status as 'healthy' | 'degraded' | 'down' | 'disabled',
+          avgLatencyMs: newAvgLatency,
+          errorRate: 1 - newSuccessRate,
+          successRate: newSuccessRate,
+          consecutiveFailures,
+          lastCheckAt: now,
+          ...(status === 'healthy' ? { lastSuccessAt: now } : {}),
+          updatedAt: now,
+        }).where(eq(providerHealth.id, row.id))
+      } else {
+        await db.insert(providerHealth).values({
+          id: uuid(),
+          providerId,
+          status: status as 'healthy' | 'degraded' | 'down' | 'disabled',
+          avgLatencyMs: latencyMs,
+          p95LatencyMs: latencyMs,
+          errorRate: status === 'healthy' ? 0 : 1,
+          successRate: status === 'healthy' ? 1 : 0,
+          consecutiveFailures: status === 'down' ? 1 : 0,
+          lastCheckAt: now,
+          lastSuccessAt: status === 'healthy' ? now : null,
+          updatedAt: now,
+        })
+      }
+    } catch (err) {
+      logger.warn({ error: (err as Error).message }, 'Failed to record health result')
+    }
+  }
+
+  async getProviderHealth(providerId?: string) {
+    try {
+      if (providerId) {
+        const rows = await db.select().from(providerHealth)
+          .where(eq(providerHealth.providerId, providerId)).limit(1)
+        return rows[0] || null
+      }
+      return await db.select().from(providerHealth)
+    } catch {
+      return []
+    }
+  }
+}
+
+export const healthChecker = new HealthChecker()

package/src/lib/mcp/builtin.ts

@@ -0,0 +1,83 @@
+import { registerTool, registerResource } from './registry'
+import { analytics } from '../analytics'
+import { memoryStore } from '../memory'
+import { semanticCacheStore } from '../cache'
+import { healthChecker } from '../health'
+
+registerTool({
+  name: 'get_usage_stats',
+  description: 'Get usage statistics for the last N days',
+  inputSchema: {
+    type: 'object',
+    properties: { days: { type: 'number', description: 'Number of days (default: 7)' } },
+  },
+  handler: async (args) => analytics.getUsageStats((args.days as number) || 7),
+})
+
+registerTool({
+  name: 'get_health_status',
+  description: 'Get health status of all providers',
+  inputSchema: { type: 'object', properties: {} },
+  handler: async () => healthChecker.getProviderHealth(),
+})
+
+registerTool({
+  name: 'get_cache_stats',
+  description: 'Get semantic cache statistics',
+  inputSchema: { type: 'object', properties: {} },
+  handler: async () => semanticCacheStore.getStats(),
+})
+
+registerTool({
+  name: 'search_memory',
+  description: 'Search persistent memory for information',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      query: { type: 'string', description: 'Search query' },
+      types: { type: 'array', items: { type: 'string' }, description: 'Memory types to search' },
+    },
+    required: ['query'],
+  },
+  handler: async (args) => memoryStore.search(args.query as string, args.types as import('../memory/types').MemoryType[] | undefined),
+})
+
+registerTool({
+  name: 'clear_cache',
+  description: 'Clear the semantic cache',
+  inputSchema: { type: 'object', properties: {} },
+  handler: async () => { await semanticCacheStore.clear(); return { success: true } },
+})
+
+registerTool({
+  name: 'trigger_distillation',
+  description: 'Trigger experience distillation run',
+  inputSchema: { type: 'object', properties: {} },
+  handler: async () => {
+    const { experienceDistiller } = await import('../distiller')
+    return experienceDistiller.run()
+  },
+})
+
+registerResource({
+  uri: 'synapse://config',
+  name: 'Synapse Configuration',
+  description: 'Current gateway configuration',
+  mimeType: 'application/json',
+  read: async () => {
+    const { loadConfig } = await import('../config')
+    const config = await loadConfig()
+    return JSON.stringify(config, null, 2)
+  },
+})
+
+registerResource({
+  uri: 'synapse://providers',
+  name: 'Provider List',
+  description: 'List of registered providers',
+  mimeType: 'application/json',
+  read: async () => {
+    const { registry } = await import('../providers/registry')
+    return JSON.stringify(registry.list().map((a) => ({ id: a.info.id, name: a.info.name, prefix: a.info.prefix })), null, 2)
+  },
+})

package/src/lib/mcp/index.ts

@@ -0,0 +1 @@
+export { registerTool, registerResource, listTools, listResources, callTool, readResource } from './registry'

package/src/lib/mcp/registry.ts

@@ -0,0 +1,49 @@
+export interface MCPTool {
+  name: string
+  description: string
+  inputSchema: Record<string, unknown>
+  handler: (args: Record<string, unknown>) => Promise<unknown>
+}
+
+export interface MCPResource {
+  uri: string
+  name: string
+  description: string
+  mimeType: string
+  read: () => Promise<string>
+}
+
+const tools: MCPTool[] = []
+const resources: MCPResource[] = []
+
+export function registerTool(tool: MCPTool) {
+  const existing = tools.findIndex((t) => t.name === tool.name)
+  if (existing >= 0) tools[existing] = tool
+  else tools.push(tool)
+}
+
+export function registerResource(resource: MCPResource) {
+  const existing = resources.findIndex((r) => r.uri === resource.uri)
+  if (existing >= 0) resources[existing] = resource
+  else resources.push(resource)
+}
+
+export function listTools(): Array<{ name: string; description: string; inputSchema: Record<string, unknown> }> {
+  return tools.map((t) => ({ name: t.name, description: t.description, inputSchema: t.inputSchema }))
+}
+
+export function listResources(): Array<{ uri: string; name: string; description: string; mimeType: string }> {
+  return resources.map((r) => ({ uri: r.uri, name: r.name, description: r.description, mimeType: r.mimeType }))
+}
+
+export async function callTool(name: string, args: Record<string, unknown>): Promise<unknown> {
+  const tool = tools.find((t) => t.name === name)
+  if (!tool) throw new Error(`Tool not found: ${name}`)
+  return tool.handler(args)
+}
+
+export async function readResource(uri: string): Promise<string> {
+  const resource = resources.find((r) => r.uri === uri)
+  if (!resource) throw new Error(`Resource not found: ${uri}`)
+  return resource.read()
+}

package/src/lib/memory/index.ts

@@ -0,0 +1,3 @@
+export type { MemoryType, EpisodicMemory, SemanticMemory, ProceduralMemory, MemorySearchResult } from './types'
+export type { EpisodeInput, KnowledgeInput, RuleInput } from './store'
+export { memoryStore } from './store'