synapse-gateway 2.0.0

package/src/lib/providers/api-key/gemini.ts

@@ -0,0 +1,112 @@
+import { BaseAdapter } from '../base-adapter'
+import type { ProviderInfo, ProviderAccount, NormalizedRequest, NormalizedResponse, NormalizedChunk, Model, HealthStatusType } from '../types'
+
+export class GeminiAdapter extends BaseAdapter {
+  info: ProviderInfo
+
+  constructor(info?: Partial<ProviderInfo>) {
+    super()
+    this.info = {
+      id: info?.id || 'gemini',
+      name: info?.name || 'Gemini',
+      prefix: info?.prefix || 'gm/',
+      authType: info?.authType || 'api_key',
+      baseUrl: info?.baseUrl || 'https://generativelanguage.googleapis.com',
+      enabled: info?.enabled ?? true,
+    }
+  }
+
+  async fetchModels(): Promise<Model[]> {
+    try {
+      const data = await this.fetchJson<{ models?: Array<{ name: string; displayName?: string; inputTokenLimit?: number; outputTokenLimit?: number }> }>(
+        `${this.info.baseUrl}/v1beta/models`,
+        { headers: {} }
+      )
+      return (data.models || [])
+        .filter((m) => m.name.includes('gemini'))
+        .map((m) => {
+          const id = m.name.replace('models/', '')
+          return {
+            id: `${this.info.prefix}${id}`,
+            name: id,
+            displayName: m.displayName || id,
+            providerId: this.info.id,
+            pricingTier: 'pay_per_use' as const,
+            contextWindow: m.inputTokenLimit,
+            available: true,
+          }
+        })
+    } catch {
+      return [
+        { id: 'gm/gemini-2.5-flash', name: 'gemini-2.5-flash', displayName: 'Gemini 2.5 Flash', providerId: this.info.id, pricingTier: 'pay_per_use', contextWindow: 1048576, available: true },
+        { id: 'gm/gemini-2.5-pro', name: 'gemini-2.5-pro', displayName: 'Gemini 2.5 Pro', providerId: this.info.id, pricingTier: 'pay_per_use', contextWindow: 2097152, available: true },
+      ]
+    }
+  }
+
+  async chatCompletion(req: NormalizedRequest, account: ProviderAccount): Promise<NormalizedResponse> {
+    const startTime = Date.now()
+    const modelName = req.model.replace('gm/', '')
+    const contents = req.messages
+      .filter((m) => m.role !== 'system')
+      .map((m) => ({
+        role: m.role === 'assistant' ? 'model' : 'user',
+        parts: [{ text: m.content }],
+      }))
+
+    const systemInstruction = req.messages.find((m) => m.role === 'system')
+
+    const geminiBody: Record<string, unknown> = {
+      contents,
+      generationConfig: {
+        temperature: req.temperature,
+        maxOutputTokens: req.maxTokens,
+      },
+    }
+    if (systemInstruction) {
+      geminiBody.systemInstruction = { parts: [{ text: systemInstruction.content }] }
+    }
+
+    const raw = await this.fetchJson<{
+      candidates?: Array<{ content?: { parts?: Array<{ text?: string }> }; finishReason?: string }>
+      usageMetadata?: { promptTokenCount?: number; candidatesTokenCount?: number; totalTokenCount?: number }
+    }>(`${this.info.baseUrl}/v1beta/models/${modelName}:generateContent?key=${account.authData.apiKey}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(geminiBody),
+    })
+
+    const content = raw.candidates?.[0]?.content?.parts?.[0]?.text || ''
+
+    return {
+      id: crypto.randomUUID(),
+      model: modelName,
+      choices: [{
+        index: 0,
+        message: { role: 'assistant', content },
+        finishReason: raw.candidates?.[0]?.finishReason || 'stop',
+      }],
+      usage: {
+        inputTokens: raw.usageMetadata?.promptTokenCount || 0,
+        outputTokens: raw.usageMetadata?.candidatesTokenCount || 0,
+        totalTokens: raw.usageMetadata?.totalTokenCount || 0,
+      },
+      latencyMs: Date.now() - startTime,
+      provider: this.info.name,
+    }
+  }
+
+  async *chatCompletionStream(): AsyncIterable<NormalizedChunk> {
+    yield { id: '', model: '', choices: [{ index: 0, delta: { content: 'Streaming not implemented for Gemini adapter yet' }, finishReason: 'stop' }] }
+  }
+
+  async healthCheck(): Promise<{ status: HealthStatusType; latencyMs: number }> {
+    const start = Date.now()
+    try {
+      await fetch(`${this.info.baseUrl}/v1beta/models?key=test`, { method: 'GET', signal: AbortSignal.timeout(10000) })
+      return { status: 'healthy', latencyMs: Date.now() - start }
+    } catch {
+      return { status: 'down', latencyMs: Date.now() - start }
+    }
+  }
+}

package/src/lib/providers/api-key/openai.ts

@@ -0,0 +1,122 @@
+import { BaseAdapter } from '../base-adapter'
+import type { ProviderInfo, ProviderAccount, NormalizedRequest, NormalizedResponse, NormalizedChunk, Model, HealthStatusType } from '../types'
+
+export class OpenAIAdapter extends BaseAdapter {
+  info: ProviderInfo
+
+  constructor(info?: Partial<ProviderInfo>) {
+    super()
+    this.info = {
+      id: info?.id || 'openai',
+      name: info?.name || 'OpenAI',
+      prefix: info?.prefix || 'oa/',
+      authType: info?.authType || 'api_key',
+      baseUrl: info?.baseUrl || 'https://api.openai.com/v1',
+      enabled: info?.enabled ?? true,
+    }
+  }
+
+  async fetchModels(): Promise<Model[]> {
+    try {
+      const data = await this.fetchJson<{ data: Array<{ id: string }> }>(
+        `${this.info.baseUrl}/models`,
+        { headers: { 'Content-Type': 'application/json' } }
+      )
+      return data.data
+        .filter((m) => m.id.startsWith('gpt-') || m.id.startsWith('o1') || m.id.startsWith('o3'))
+        .map((m) => ({
+          id: `${this.info.prefix}${m.id}`,
+          name: m.id,
+          displayName: m.id,
+          providerId: this.info.id,
+          pricingTier: 'pay_per_use' as const,
+          available: true,
+        }))
+    } catch {
+      return []
+    }
+  }
+
+  async chatCompletion(req: NormalizedRequest, account: ProviderAccount): Promise<NormalizedResponse> {
+    const startTime = Date.now()
+    const body = this.createOpenAIRequest(req)
+
+    const raw = await this.fetchJson<{
+      id?: string
+      model?: string
+      choices?: Array<{ index?: number; message?: { role?: string; content?: string }; finish_reason?: string }>
+      usage?: { prompt_tokens?: number; completion_tokens?: number; total_tokens?: number }
+    }>(`${this.info.baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${account.authData.apiKey}`,
+      },
+      body: JSON.stringify(body),
+    })
+
+    return this.parseOpenAIResponse(raw, this.info.name, startTime)
+  }
+
+  async *chatCompletionStream(req: NormalizedRequest, account: ProviderAccount): AsyncIterable<NormalizedChunk> {
+    const body = { ...this.createOpenAIRequest(req), stream: true }
+    const response = await this.fetchWithRetry(`${this.info.baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${account.authData.apiKey}`,
+      },
+      body: JSON.stringify(body),
+    })
+
+    if (!response.body) return
+
+    const reader = response.body.getReader()
+    const decoder = new TextDecoder()
+    let buffer = ''
+
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+
+      buffer += decoder.decode(value, { stream: true })
+      const lines = buffer.split('\n')
+      buffer = lines.pop() || ''
+
+      for (const line of lines) {
+        const trimmed = line.trim()
+        if (!trimmed.startsWith('data: ')) continue
+        const data = trimmed.slice(6)
+        if (data === '[DONE]') return
+
+        try {
+          const parsed = JSON.parse(data)
+          yield {
+            id: parsed.id || '',
+            model: parsed.model || '',
+            choices: (parsed.choices || []).map((c: Record<string, unknown>) => ({
+              index: (c.index as number) || 0,
+              delta: {
+                role: (c.delta as Record<string, unknown>)?.role as 'assistant' | undefined,
+                content: (c.delta as Record<string, unknown>)?.content as string | undefined,
+              },
+              finishReason: (c.finish_reason as string) || null,
+            })),
+          }
+        } catch {
+          continue
+        }
+      }
+    }
+  }
+
+  async healthCheck(): Promise<{ status: HealthStatusType; latencyMs: number }> {
+    const start = Date.now()
+    try {
+      await fetch(`${this.info.baseUrl}/models`, { method: 'GET', signal: AbortSignal.timeout(10000) })
+      return { status: 'healthy', latencyMs: Date.now() - start }
+    } catch {
+      return { status: 'down', latencyMs: Date.now() - start }
+    }
+  }
+}

package/src/lib/providers/api-key/openrouter.ts

@@ -0,0 +1,112 @@
+import { BaseAdapter } from '../base-adapter'
+import type { ProviderInfo, ProviderAccount, NormalizedRequest, NormalizedResponse, NormalizedChunk, Model, HealthStatusType } from '../types'
+
+export class OpenRouterAdapter extends BaseAdapter {
+  info: ProviderInfo
+
+  constructor(info?: Partial<ProviderInfo>) {
+    super()
+    this.info = {
+      id: info?.id || 'openrouter',
+      name: info?.name || 'OpenRouter',
+      prefix: info?.prefix || 'or/',
+      authType: info?.authType || 'api_key',
+      baseUrl: info?.baseUrl || 'https://openrouter.ai/api/v1',
+      enabled: info?.enabled ?? true,
+    }
+  }
+
+  async fetchModels(): Promise<Model[]> {
+    try {
+      const data = await this.fetchJson<{ data: Array<{ id: string; name?: string; context_length?: number; pricing?: { prompt?: string; completion?: string } }> }>(
+        `${this.info.baseUrl}/models`,
+        { headers: { 'Content-Type': 'application/json' } }
+      )
+      return data.data.map((m) => ({
+        id: `${this.info.prefix}${m.id}`,
+        name: m.id,
+        displayName: m.name || m.id,
+        providerId: this.info.id,
+        pricingTier: 'pay_per_use' as const,
+        costPer1mInput: m.pricing?.prompt ? parseFloat(m.pricing.prompt) * 1_000_000 : undefined,
+        costPer1mOutput: m.pricing?.completion ? parseFloat(m.pricing.completion) * 1_000_000 : undefined,
+        contextWindow: m.context_length,
+        available: true,
+      }))
+    } catch {
+      return []
+    }
+  }
+
+  async chatCompletion(req: NormalizedRequest, account: ProviderAccount): Promise<NormalizedResponse> {
+    const startTime = Date.now()
+    const body = this.createOpenAIRequest(req)
+    const raw = await this.fetchJson<{
+      id?: string; model?: string
+      choices?: Array<{ index?: number; message?: { role?: string; content?: string }; finish_reason?: string }>
+      usage?: { prompt_tokens?: number; completion_tokens?: number; total_tokens?: number }
+    }>(`${this.info.baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${account.authData.apiKey}`,
+        'HTTP-Referer': 'https://synapse.dev',
+        'X-Title': 'Synapse',
+      },
+      body: JSON.stringify(body),
+    })
+    return this.parseOpenAIResponse(raw, this.info.name, startTime)
+  }
+
+  async *chatCompletionStream(req: NormalizedRequest, account: ProviderAccount): AsyncIterable<NormalizedChunk> {
+    const body = { ...this.createOpenAIRequest(req), stream: true }
+    const response = await this.fetchWithRetry(`${this.info.baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${account.authData.apiKey}`,
+        'HTTP-Referer': 'https://synapse.dev',
+        'X-Title': 'Synapse',
+      },
+      body: JSON.stringify(body),
+    })
+    if (!response.body) return
+    const reader = response.body.getReader()
+    const decoder = new TextDecoder()
+    let buffer = ''
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      buffer += decoder.decode(value, { stream: true })
+      const lines = buffer.split('\n')
+      buffer = lines.pop() || ''
+      for (const line of lines) {
+        const trimmed = line.trim()
+        if (!trimmed.startsWith('data: ')) continue
+        const data = trimmed.slice(6)
+        if (data === '[DONE]') return
+        try {
+          const parsed = JSON.parse(data)
+          yield {
+            id: parsed.id || '', model: parsed.model || '',
+            choices: (parsed.choices || []).map((c: Record<string, unknown>) => ({
+              index: (c.index as number) || 0,
+              delta: { role: (c.delta as Record<string, unknown>)?.role as 'assistant' | undefined, content: (c.delta as Record<string, unknown>)?.content as string | undefined },
+              finishReason: (c.finish_reason as string) || null,
+            })),
+          }
+        } catch { continue }
+      }
+    }
+  }
+
+  async healthCheck(): Promise<{ status: HealthStatusType; latencyMs: number }> {
+    const start = Date.now()
+    try {
+      await fetch(`${this.info.baseUrl}/models`, { method: 'GET', signal: AbortSignal.timeout(10000) })
+      return { status: 'healthy', latencyMs: Date.now() - start }
+    } catch {
+      return { status: 'down', latencyMs: Date.now() - start }
+    }
+  }
+}

package/src/lib/providers/base-adapter.ts

@@ -0,0 +1,122 @@
+import type {
+  ProviderAdapter,
+  ProviderInfo,
+  ProviderAccount,
+  NormalizedRequest,
+  NormalizedResponse,
+  NormalizedChunk,
+  Model,
+  HealthStatusType,
+  Message,
+} from './types'
+
+export abstract class BaseAdapter implements ProviderAdapter {
+  abstract info: ProviderInfo
+
+  protected timeout = 30000
+  protected maxRetries = 3
+
+  abstract fetchModels(): Promise<Model[]>
+  abstract chatCompletion(req: NormalizedRequest, account: ProviderAccount): Promise<NormalizedResponse>
+  abstract chatCompletionStream(req: NormalizedRequest, account: ProviderAccount): AsyncIterable<NormalizedChunk>
+  abstract healthCheck(): Promise<{ status: HealthStatusType; latencyMs: number }>
+
+  protected async fetchWithRetry(
+    url: string,
+    options: RequestInit,
+    maxRetries = this.maxRetries
+  ): Promise<Response> {
+    let lastError: Error | null = null
+
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      try {
+        const controller = new AbortController()
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout)
+
+        const response = await fetch(url, {
+          ...options,
+          signal: controller.signal,
+        })
+
+        clearTimeout(timeoutId)
+
+        if (response.status === 429 && attempt < maxRetries - 1) {
+          const delay = Math.pow(2, attempt) * 1000 + Math.random() * 1000
+          await new Promise((resolve) => setTimeout(resolve, delay))
+          continue
+        }
+
+        return response
+      } catch (error) {
+        lastError = error as Error
+        if (attempt < maxRetries - 1) {
+          const delay = Math.pow(2, attempt) * 500
+          await new Promise((resolve) => setTimeout(resolve, delay))
+        }
+      }
+    }
+
+    throw lastError || new Error('Request failed after retries')
+  }
+
+  protected async fetchJson<T>(url: string, options: RequestInit): Promise<T> {
+    const response = await this.fetchWithRetry(url, options)
+    if (!response.ok) {
+      const body = await response.text().catch(() => '')
+      throw new Error(`HTTP ${response.status}: ${body}`)
+    }
+    return response.json() as Promise<T>
+  }
+
+  protected createOpenAIRequest(req: NormalizedRequest): Record<string, unknown> {
+    const body: Record<string, unknown> = {
+      model: req.model,
+      messages: req.messages.map((m) => ({
+        role: m.role,
+        content: m.content,
+      })),
+      stream: req.stream ?? false,
+    }
+
+    if (req.temperature !== undefined) body.temperature = req.temperature
+    if (req.maxTokens !== undefined) body.max_tokens = req.maxTokens
+    if (req.tools) body.tools = req.tools
+
+    return body
+  }
+
+  protected parseOpenAIResponse(raw: {
+    id?: string
+    model?: string
+    choices?: Array<{
+      index?: number
+      message?: { role?: string; content?: string; tool_calls?: unknown[] }
+      finish_reason?: string
+    }>
+    usage?: { prompt_tokens?: number; completion_tokens?: number; total_tokens?: number }
+  }, providerName: string, startTime: number): NormalizedResponse {
+    const message: Message = {
+      role: 'assistant',
+      content: raw.choices?.[0]?.message?.content || '',
+    }
+
+    return {
+      id: raw.id || crypto.randomUUID(),
+      model: raw.model || '',
+      choices: [
+        {
+          index: raw.choices?.[0]?.index || 0,
+          message,
+          finishReason: raw.choices?.[0]?.finish_reason || 'stop',
+        },
+      ],
+      usage: {
+        inputTokens: raw.usage?.prompt_tokens || 0,
+        outputTokens: raw.usage?.completion_tokens || 0,
+        totalTokens: raw.usage?.total_tokens || 0,
+      },
+      latencyMs: Date.now() - startTime,
+      provider: providerName,
+    }
+  }
+}

package/src/lib/providers/registry.ts

@@ -0,0 +1,46 @@
+import type { ProviderAdapter, MeshProvider, ProviderAccount, Model } from './types'
+
+class ProviderRegistry {
+  private adapters = new Map<string, ProviderAdapter>()
+
+  register(adapter: ProviderAdapter): void {
+    this.adapters.set(adapter.info.prefix, adapter)
+  }
+
+  unregister(prefix: string): void {
+    this.adapters.delete(prefix)
+  }
+
+  get(prefix: string): ProviderAdapter | undefined {
+    return this.adapters.get(prefix)
+  }
+
+  list(): ProviderAdapter[] {
+    return Array.from(this.adapters.values())
+  }
+
+  resolveModel(modelId: string): { adapter: ProviderAdapter; modelName: string } | null {
+    const slashIndex = modelId.indexOf('/')
+    if (slashIndex === -1) return null
+
+    const prefix = modelId.substring(0, slashIndex) + '/'
+    const modelName = modelId.substring(slashIndex + 1)
+
+    const adapter = this.adapters.get(prefix)
+    if (!adapter) return null
+
+    return { adapter, modelName }
+  }
+
+  resolveAllProviders(modelName: string): Array<{ adapter: ProviderAdapter; localName: string }> {
+    const results: Array<{ adapter: ProviderAdapter; localName: string }> = []
+
+    for (const adapter of this.adapters.values()) {
+      results.push({ adapter, localName: modelName })
+    }
+
+    return results
+  }
+}
+
+export const registry = new ProviderRegistry()

package/src/lib/providers/types.ts

@@ -0,0 +1,121 @@
+export type AuthType = 'oauth' | 'api_key' | 'none' | 'service_account'
+export type PricingTier = 'free' | 'cheap' | 'subscription' | 'pay_per_use'
+export type HealthStatusType = 'healthy' | 'degraded' | 'down' | 'disabled'
+export type TaskType = 'code' | 'chat' | 'reason' | 'review' | 'debug' | 'doc' | 'translate' | 'fast'
+
+export interface Model {
+  id: string
+  name: string
+  displayName?: string
+  providerId: string
+  pricingTier?: PricingTier
+  costPer1mInput?: number
+  costPer1mOutput?: number
+  contextWindow?: number
+  capabilities?: string[]
+  available: boolean
+}
+
+export interface ProviderInfo {
+  id: string
+  name: string
+  prefix: string
+  authType: AuthType
+  baseUrl: string
+  enabled: boolean
+}
+
+export interface ProviderAccount {
+  id: string
+  providerId: string
+  label?: string
+  authData: Record<string, unknown>
+  enabled: boolean
+  priority: number
+  quotaUsedTokens: number
+  quotaLimitTokens?: number
+  quotaResetAt?: Date
+  lastUsedAt?: Date
+}
+
+export interface Message {
+  role: 'system' | 'user' | 'assistant' | 'tool'
+  content: string
+  toolCallId?: string
+  toolCalls?: ToolCall[]
+}
+
+export interface ToolCall {
+  id: string
+  type: 'function'
+  function: { name: string; arguments: string }
+}
+
+export interface NormalizedRequest {
+  model: string
+  messages: Message[]
+  temperature?: number
+  maxTokens?: number
+  stream?: boolean
+  tools?: unknown[]
+  metadata?: Record<string, unknown>
+  skillId?: string
+  taskType?: TaskType
+}
+
+export interface NormalizedResponse {
+  id: string
+  model: string
+  choices: Array<{
+    index: number
+    message: Message
+    finishReason: string
+  }>
+  usage: {
+    inputTokens: number
+    outputTokens: number
+    totalTokens: number
+  }
+  latencyMs: number
+  provider: string
+}
+
+export interface NormalizedChunk {
+  id: string
+  model: string
+  choices: Array<{
+    index: number
+    delta: Partial<Message>
+    finishReason: string | null
+  }>
+  usage?: {
+    inputTokens: number
+    outputTokens: number
+    totalTokens: number
+  }
+}
+
+export interface QuotaInfo {
+  usedTokens: number
+  limitTokens?: number
+  resetAt?: Date
+  unlimited: boolean
+}
+
+export interface ProviderAdapter {
+  info: ProviderInfo
+  fetchModels(): Promise<Model[]>
+  chatCompletion(req: NormalizedRequest, account: ProviderAccount): Promise<NormalizedResponse>
+  chatCompletionStream(req: NormalizedRequest, account: ProviderAccount): AsyncIterable<NormalizedChunk>
+  healthCheck(): Promise<{ status: HealthStatusType; latencyMs: number }>
+  getQuota?(account: ProviderAccount): Promise<QuotaInfo>
+}
+
+export interface MeshProvider {
+  provider: ProviderInfo
+  account: ProviderAccount
+  model: Model
+  health: HealthStatusType
+  cost: number
+  latency: number
+}