synapse-gateway 2.0.0

package/src/lib/pipeline/index.ts

@@ -0,0 +1,84 @@
+import { db } from '../db'
+import { pipelines } from '../db/schema'
+import { eq } from 'drizzle-orm'
+import { DEFAULT_PIPELINE } from './types'
+import type { Pipeline, PipelineNode, PipelineConnection } from './types'
+import { logger } from '../utils/logger'
+import { v4 as uuid } from 'uuid'
+
+class PipelineEngine {
+  async list(): Promise<Pipeline[]> {
+    try {
+      const rows = await db.select().from(pipelines)
+      return rows.map((r) => ({
+        id: r.id,
+        name: r.name,
+        description: r.description || '',
+        nodes: JSON.parse(r.nodes),
+        connections: JSON.parse(r.connections),
+        isDefault: !!r.isDefault,
+      }))
+    } catch {
+      return [DEFAULT_PIPELINE]
+    }
+  }
+
+  async getDefault(): Promise<Pipeline> {
+    try {
+      const rows = await db.select().from(pipelines).where(eq(pipelines.isDefault, true)).limit(1)
+      if (rows.length > 0) {
+        return {
+          id: rows[0].id,
+          name: rows[0].name,
+          description: rows[0].description || '',
+          nodes: JSON.parse(rows[0].nodes),
+          connections: JSON.parse(rows[0].connections),
+          isDefault: true,
+        }
+      }
+    } catch { /* ignore */ }
+    return DEFAULT_PIPELINE
+  }
+
+  async create(pipeline: Omit<Pipeline, 'id'>): Promise<string> {
+    const id = uuid()
+    try {
+      await db.insert(pipelines).values({
+        id,
+        name: pipeline.name,
+        description: pipeline.description,
+        nodes: JSON.stringify(pipeline.nodes),
+        connections: JSON.stringify(pipeline.connections),
+        isDefault: pipeline.isDefault ?? false,
+      })
+    } catch (err) {
+      logger.warn({ error: (err as Error).message }, 'Failed to create pipeline')
+    }
+    return id
+  }
+
+  async update(id: string, updates: Partial<Pipeline>): Promise<void> {
+    try {
+      const set: Record<string, unknown> = { updatedAt: new Date().toISOString() }
+      if (updates.name !== undefined) set.name = updates.name
+      if (updates.description !== undefined) set.description = updates.description
+      if (updates.nodes !== undefined) set.nodes = JSON.stringify(updates.nodes)
+      if (updates.connections !== undefined) set.connections = JSON.stringify(updates.connections)
+      if (updates.isDefault !== undefined) set.isDefault = updates.isDefault
+
+      await db.update(pipelines).set(set).where(eq(pipelines.id, id))
+    } catch (err) {
+      logger.warn({ error: (err as Error).message }, 'Failed to update pipeline')
+    }
+  }
+
+  async delete(id: string): Promise<void> {
+    try {
+      await db.delete(pipelines).where(eq(pipelines.id, id))
+    } catch (err) {
+      logger.warn({ error: (err as Error).message }, 'Failed to delete pipeline')
+    }
+  }
+}
+
+export const pipelineEngine = new PipelineEngine()

package/src/lib/pipeline/types.ts

@@ -0,0 +1,77 @@
+export type NodeType = 'input' | 'cache_check' | 'squeezer' | 'router' | 'provider_call' | 'fallback' | 'skill_apply' | 'cache_store' | 'benchmark' | 'plugin' | 'output' | 'condition'
+
+export interface PipelineNode {
+  id: string
+  type: NodeType
+  label: string
+  config: Record<string, unknown>
+  position: { x: number; y: number }
+}
+
+export interface PipelineConnection {
+  id: string
+  source: string
+  target: string
+  condition?: string
+}
+
+export interface Pipeline {
+  id: string
+  name: string
+  description: string
+  nodes: PipelineNode[]
+  connections: PipelineConnection[]
+  isDefault: boolean
+}
+
+export interface PipelineContext {
+  request: import('../providers/types').NormalizedRequest
+  response?: import('../providers/types').NormalizedResponse
+  metadata: Record<string, unknown>
+  currentNode?: string
+  history: Array<{ node: string; result: string; durationMs: number }>
+}
+
+const DEFAULT_PIPELINE_NODES: PipelineNode[] = [
+  { id: 'input', type: 'input', label: 'Request Input', config: {}, position: { x: 0, y: 0 } },
+  { id: 'cache', type: 'cache_check', label: 'Cache Check', config: {}, position: { x: 200, y: 0 } },
+  { id: 'squeeze', type: 'squeezer', label: 'Token Squeezer', config: { level: 'balanced' }, position: { x: 400, y: 0 } },
+  { id: 'skill', type: 'skill_apply', label: 'Apply Skill', config: {}, position: { x: 600, y: -100 } },
+  { id: 'router', type: 'router', label: 'Neural Router', config: { strategy: 'hybrid' }, position: { x: 600, y: 100 } },
+  { id: 'provider', type: 'provider_call', label: 'Provider Call', config: {}, position: { x: 800, y: 0 } },
+  { id: 'fallback', type: 'fallback', label: 'Fallback Engine', config: {}, position: { x: 1000, y: 0 } },
+  { id: 'benchmark', type: 'benchmark', label: 'Benchmark', config: { enabled: false }, position: { x: 1200, y: -100 } },
+  { id: 'plugin', type: 'plugin', label: 'Post-Process', config: { plugins: [] }, position: { x: 1200, y: 100 } },
+  { id: 'cache_store', type: 'cache_store', label: 'Cache Store', config: {}, position: { x: 1400, y: 0 } },
+  { id: 'output', type: 'output', label: 'Response Output', config: {}, position: { x: 1600, y: 0 } },
+]
+
+const DEFAULT_PIPELINE_CONNECTIONS: PipelineConnection[] = [
+  { id: 'c1', source: 'input', target: 'cache' },
+  { id: 'c2', source: 'cache', target: 'squeeze', condition: 'cache_miss' },
+  { id: 'c3', source: 'squeeze', target: 'skill' },
+  { id: 'c4', source: 'squeeze', target: 'router' },
+  { id: 'c5', source: 'router', target: 'provider' },
+  { id: 'c6', source: 'provider', target: 'fallback', condition: 'error' },
+  { id: 'c7', source: 'provider', target: 'benchmark', condition: 'success' },
+  { id: 'c8', source: 'provider', target: 'plugin', condition: 'success' },
+  { id: 'c9', source: 'fallback', target: 'plugin', condition: 'success' },
+  { id: 'c10', source: 'plugin', target: 'cache_store' },
+  { id: 'c11', source: 'cache_store', target: 'output' },
+  { id: 'c12', source: 'cache', target: 'output', condition: 'cache_hit' },
+]
+
+export const DEFAULT_PIPELINE: Pipeline = {
+  id: 'default',
+  name: 'Default Pipeline',
+  description: 'Standard request processing pipeline with cache, squeeze, route, fallback',
+  nodes: DEFAULT_PIPELINE_NODES,
+  connections: DEFAULT_PIPELINE_CONNECTIONS,
+  isDefault: true,
+}
+
+export function getNodesAfter(pipeline: Pipeline, nodeId: string, condition?: string): PipelineConnection[] {
+  return pipeline.connections.filter(
+    (c) => c.source === nodeId && (!condition || c.condition === condition || !c.condition),
+  )
+}

package/src/lib/plugins/builtin.ts

@@ -0,0 +1,79 @@
+import { pluginManager } from './index'
+import type { Plugin, PluginContext } from './index'
+
+const piiPatterns = [
+  /\b\d{3}[-.]?\d{2}[-.]?\d{4}\b/g,
+  /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g,
+  /\b(?:\+?1[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g,
+  /\b\d{3}[-.]?\d{3}[-.]?\d{3}[-.]?\d{4}\b/g,
+  /\b(?:4\d{3}|5[1-5]\d{2}|2\d{3}|3[47]\d{2})[-\s.]?\d{4}[-\s.]?\d{4}[-\s.]?\d{4}\b/g,
+]
+
+const piiPlugin: Plugin = {
+  name: 'pii-redactor',
+  description: 'Redacts personally identifiable information (SSN, email, phone, credit card)',
+  phase: 'pre_request',
+  execute: async (ctx: PluginContext) => {
+    let content = ctx.content
+    let modified = false
+
+    for (const pattern of piiPatterns) {
+      if (pattern.test(content)) {
+        content = content.replace(pattern, '[REDACTED]')
+        modified = true
+      }
+    }
+
+    return { modified, content }
+  },
+}
+
+pluginManager.register(piiPlugin)
+
+const profanityWords = ['damn', 'hell', 'crap']
+const profanityPlugin: Plugin = {
+  name: 'profanity-filter',
+  description: 'Filters profanity from responses',
+  phase: 'post_response',
+  execute: async (ctx: PluginContext) => {
+    let content = ctx.content
+    let modified = false
+
+    for (const word of profanityWords) {
+      const regex = new RegExp(`\\b${word}\\b`, 'gi')
+      if (regex.test(content)) {
+        content = content.replace(regex, '*'.repeat(word.length))
+        modified = true
+      }
+    }
+
+    return { modified, content }
+  },
+}
+
+pluginManager.register(profanityPlugin)
+
+const responseValidator: Plugin = {
+  name: 'response-validator',
+  description: 'Validates response is not empty and has reasonable length',
+  phase: 'post_response',
+  execute: async (ctx: PluginContext) => {
+    const issues: string[] = []
+
+    if (!ctx.content || ctx.content.trim().length === 0) {
+      issues.push('empty_response')
+    }
+
+    if (ctx.content.length > 100000) {
+      issues.push('response_too_long')
+    }
+
+    return {
+      modified: false,
+      content: ctx.content,
+      metadata: { validation: { valid: issues.length === 0, issues } },
+    }
+  },
+}
+
+pluginManager.register(responseValidator)

package/src/lib/plugins/index.ts

@@ -0,0 +1,65 @@
+export interface Plugin {
+  name: string
+  description: string
+  phase: 'pre_request' | 'post_response' | 'both'
+  execute: (context: PluginContext) => Promise<PluginResult>
+}
+
+export interface PluginContext {
+  type: 'request' | 'response'
+  content: string
+  model: string
+  provider: string
+  metadata: Record<string, unknown>
+}
+
+export interface PluginResult {
+  modified: boolean
+  content: string
+  metadata?: Record<string, unknown>
+}
+
+class PluginManager {
+  private plugins = new Map<string, Plugin>()
+
+  register(plugin: Plugin) {
+    this.plugins.set(plugin.name, plugin)
+  }
+
+  unregister(name: string) {
+    this.plugins.delete(name)
+  }
+
+  async executePhase(phase: 'pre_request' | 'post_response', context: PluginContext): Promise<PluginContext> {
+    let current = context
+
+    for (const plugin of this.plugins.values()) {
+      if (plugin.phase !== phase && plugin.phase !== 'both') continue
+
+      try {
+        const result = await plugin.execute(current)
+        if (result.modified) {
+          current = {
+            ...current,
+            content: result.content,
+            metadata: { ...current.metadata, ...result.metadata },
+          }
+        }
+      } catch {
+        // plugin error doesn't stop pipeline
+      }
+    }
+
+    return current
+  }
+
+  list(): Array<{ name: string; description: string; phase: string }> {
+    return Array.from(this.plugins.values()).map((p) => ({
+      name: p.name,
+      description: p.description,
+      phase: p.phase,
+    }))
+  }
+}
+
+export const pluginManager = new PluginManager()

package/src/lib/prediction/index.ts

@@ -0,0 +1,113 @@
+import { db } from '../db'
+import { usageDaily, settings } from '../db/schema'
+import { sql, and, gte, lte } from 'drizzle-orm'
+import { logger } from '../utils/logger'
+
+export interface CostForecast {
+  currentMonthSpend: number
+  projectedMonthSpend: number
+  monthlyBudget: number
+  budgetUsedPercent: number
+  daysRemaining: number
+  dailyBurnRate: number
+  daysUntilBudgetExhausted: number
+  recommendation: 'normal' | 'cost_saving' | 'budget_conserving' | 'strict_free'
+}
+
+export interface ModelCostComparison {
+  model: string
+  providerId: string
+  costPerRequest: number
+  avgLatency: number
+  qualityScore: number
+  valueScore: number
+}
+
+class PredictiveCostEngine {
+  async getForecast(): Promise<CostForecast> {
+    try {
+      const now = new Date()
+      const monthStart = new Date(now.getFullYear(), now.getMonth(), 1).toISOString().split('T')[0]
+      const today = now.toISOString().split('T')[0]
+      const daysInMonth = new Date(now.getFullYear(), now.getMonth() + 1, 0).getDate()
+      const daysElapsed = now.getDate()
+      const daysRemaining = daysInMonth - daysElapsed
+
+      const [monthStats] = await db.select({
+        spend: sql<number>`coalesce(sum(${usageDaily.totalCost}), 0)`,
+        requests: sql<number>`coalesce(sum(${usageDaily.totalRequests}), 0)`,
+      }).from(usageDaily).where(gte(usageDaily.date, monthStart))
+
+      const currentMonthSpend = Number(monthStats?.spend ?? 0)
+      const totalRequests = monthStats?.requests ?? 0
+      const dailyBurnRate = daysElapsed > 0 ? currentMonthSpend / daysElapsed : 0
+      const projectedMonthSpend = dailyBurnRate * daysInMonth
+
+      let monthlyBudget = 100
+      try {
+        const [budgetRow] = await db.select().from(settings).where(sql`${settings.key} = 'monthly_budget'`).limit(1)
+        if (budgetRow) monthlyBudget = Number(budgetRow.value)
+      } catch { /* ignore */ }
+
+      const budgetUsedPercent = monthlyBudget > 0 ? (currentMonthSpend / monthlyBudget) * 100 : 0
+      const daysUntilBudgetExhausted = dailyBurnRate > 0 ? Math.floor((monthlyBudget - currentMonthSpend) / dailyBurnRate) : Infinity
+
+      let recommendation: CostForecast['recommendation'] = 'normal'
+      if (budgetUsedPercent > 95) recommendation = 'strict_free'
+      else if (budgetUsedPercent > 80) recommendation = 'budget_conserving'
+      else if (budgetUsedPercent > 60) recommendation = 'cost_saving'
+
+      return {
+        currentMonthSpend,
+        projectedMonthSpend,
+        monthlyBudget,
+        budgetUsedPercent,
+        daysRemaining,
+        dailyBurnRate,
+        daysUntilBudgetExhausted: Math.max(daysUntilBudgetExhausted, 0),
+        recommendation,
+      }
+    } catch {
+      return {
+        currentMonthSpend: 0, projectedMonthSpend: 0, monthlyBudget: 100,
+        budgetUsedPercent: 0, daysRemaining: 30, dailyBurnRate: 0,
+        daysUntilBudgetExhausted: Infinity, recommendation: 'normal',
+      }
+    }
+  }
+
+  async getModelCostComparison(): Promise<ModelCostComparison[]> {
+    try {
+      const rows = await db.select({
+        model: usageDaily.model,
+        provider: usageDaily.providerId,
+        totalCost: sql<number>`coalesce(sum(${usageDaily.totalCost}), 0)`,
+        totalRequests: sql<number>`coalesce(sum(${usageDaily.totalRequests}), 0)`,
+      }).from(usageDaily)
+        .where(sql`${usageDaily.model} IS NOT NULL`)
+        .groupBy(usageDaily.model, usageDaily.providerId)
+
+      return rows.map((r) => ({
+        model: r.model || '',
+        providerId: r.provider || '',
+        costPerRequest: r.totalRequests > 0 ? Number(r.totalCost) / r.totalRequests : 0,
+        avgLatency: 0,
+        qualityScore: 0,
+        valueScore: r.totalRequests > 0 ? (1 / (Number(r.totalCost) / r.totalRequests + 0.001)) : 0,
+      }))
+    } catch {
+      return []
+    }
+  }
+
+  async setBudget(amount: number) {
+    try {
+      await db.insert(settings).values({ key: 'monthly_budget', value: String(amount) })
+        .onConflictDoUpdate({ target: settings.key, set: { value: String(amount) } })
+    } catch (err) {
+      logger.warn({ error: (err as Error).message }, 'Failed to set budget')
+    }
+  }
+}
+
+export const costEngine = new PredictiveCostEngine()

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

@@ -0,0 +1,96 @@
+import { BaseAdapter } from '../base-adapter'
+import type { ProviderInfo, ProviderAccount, NormalizedRequest, NormalizedResponse, Model, HealthStatusType } from '../types'
+
+export class AnthropicAdapter extends BaseAdapter {
+  info: ProviderInfo
+
+  constructor(info?: Partial<ProviderInfo>) {
+    super()
+    this.info = {
+      id: info?.id || 'anthropic',
+      name: info?.name || 'Anthropic',
+      prefix: info?.prefix || 'an/',
+      authType: info?.authType || 'api_key',
+      baseUrl: info?.baseUrl || 'https://api.anthropic.com',
+      enabled: info?.enabled ?? true,
+    }
+  }
+
+  private staticModels: Model[] = [
+    { id: 'an/claude-opus-4-7', name: 'claude-opus-4-7', displayName: 'Claude Opus 4.7', providerId: 'anthropic', pricingTier: 'pay_per_use', costPer1mInput: 15, costPer1mOutput: 75, contextWindow: 200000, capabilities: ['streaming', 'tools', 'vision'], available: true },
+    { id: 'an/claude-sonnet-4-5', name: 'claude-sonnet-4-5', displayName: 'Claude Sonnet 4.5', providerId: 'anthropic', pricingTier: 'pay_per_use', costPer1mInput: 3, costPer1mOutput: 15, contextWindow: 200000, capabilities: ['streaming', 'tools', 'vision'], available: true },
+    { id: 'an/claude-haiku-4-5', name: 'claude-haiku-4-5', displayName: 'Claude Haiku 4.5', providerId: 'anthropic', pricingTier: 'pay_per_use', costPer1mInput: 0.8, costPer1mOutput: 4, contextWindow: 200000, capabilities: ['streaming', 'tools', 'vision'], available: true },
+  ]
+
+  async fetchModels(): Promise<Model[]> {
+    return this.staticModels
+  }
+
+  async chatCompletion(req: NormalizedRequest, account: ProviderAccount): Promise<NormalizedResponse> {
+    const startTime = Date.now()
+    const systemMsg = req.messages.find((m) => m.role === 'system')
+    const nonSystemMsgs = req.messages.filter((m) => m.role !== 'system')
+
+    const claudeBody: Record<string, unknown> = {
+      model: req.model.replace('an/', ''),
+      messages: nonSystemMsgs.map((m) => ({ role: m.role, content: m.content })),
+      max_tokens: req.maxTokens || 4096,
+      stream: false,
+    }
+    if (systemMsg) claudeBody.system = systemMsg.content
+
+    const raw = await this.fetchJson<{
+      id?: string
+      model?: string
+      content?: Array<{ type: string; text?: string }>
+      stop_reason?: string
+      usage?: { input_tokens?: number; output_tokens?: number }
+    }>(`${this.info.baseUrl}/v1/messages`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': account.authData.apiKey as string,
+        'anthropic-version': '2023-06-01',
+      },
+      body: JSON.stringify(claudeBody),
+    })
+
+    const content = raw.content?.find((c) => c.type === 'text')?.text || ''
+
+    return {
+      id: raw.id || crypto.randomUUID(),
+      model: raw.model || req.model,
+      choices: [{
+        index: 0,
+        message: { role: 'assistant', content },
+        finishReason: raw.stop_reason || 'stop',
+      }],
+      usage: {
+        inputTokens: raw.usage?.input_tokens || 0,
+        outputTokens: raw.usage?.output_tokens || 0,
+        totalTokens: (raw.usage?.input_tokens || 0) + (raw.usage?.output_tokens || 0),
+      },
+      latencyMs: Date.now() - startTime,
+      provider: this.info.name,
+    }
+  }
+
+  async *chatCompletionStream(): AsyncIterable<import('../types').NormalizedChunk> {
+    yield { id: '', model: '', choices: [{ index: 0, delta: { content: 'Streaming not implemented for Anthropic adapter yet' }, finishReason: 'stop' }] }
+  }
+
+  async healthCheck(): Promise<{ status: HealthStatusType; latencyMs: number }> {
+    const start = Date.now()
+    try {
+      await fetch(`${this.info.baseUrl}/v1/messages`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'x-api-key': 'test', 'anthropic-version': '2023-06-01' },
+        body: JSON.stringify({ model: 'claude-haiku-4-5', messages: [{ role: 'user', content: 'hi' }], max_tokens: 1 }),
+        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/deepseek.ts

@@ -0,0 +1,108 @@
+import { BaseAdapter } from '../base-adapter'
+import type { ProviderInfo, ProviderAccount, NormalizedRequest, NormalizedResponse, NormalizedChunk, Model, HealthStatusType } from '../types'
+
+export class DeepSeekAdapter extends BaseAdapter {
+  info: ProviderInfo
+
+  constructor(info?: Partial<ProviderInfo>) {
+    super()
+    this.info = {
+      id: info?.id || 'deepseek',
+      name: info?.name || 'DeepSeek',
+      prefix: info?.prefix || 'ds/',
+      authType: info?.authType || 'api_key',
+      baseUrl: info?.baseUrl || 'https://api.deepseek.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.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 [
+        { id: 'ds/deepseek-chat', name: 'deepseek-chat', displayName: 'DeepSeek Chat', providerId: this.info.id, pricingTier: 'pay_per_use', available: true },
+        { id: 'ds/deepseek-reasoner', name: 'deepseek-reasoner', displayName: 'DeepSeek Reasoner', providerId: this.info.id, pricingTier: 'pay_per_use', available: true },
+      ]
+    }
+  }
+
+  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; reasoning_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),
+    })
+
+    const resp = this.parseOpenAIResponse(raw, this.info.name, startTime)
+    if (raw.choices?.[0]?.message?.reasoning_content) {
+      resp.choices[0].message.content = raw.choices[0].message.reasoning_content + '\n' + (raw.choices[0].message.content || '')
+    }
+    return resp
+  }
+
+  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 }
+    }
+  }
+}