gavio 0.1.0 → 0.2.0

package/src/interceptors/reliability/index.ts

@@ -6,3 +6,7 @@ export { timeoutPolicy, timeout } from './timeout.js'
 export type { TimeoutPolicyOptions } from './timeout.js'
 export { fallbackChain } from './fallback.js'
 export type { FallbackChainOptions } from './fallback.js'
+export { circuitBreaker, CircuitState } from './circuit-breaker.js'
+export type { CircuitBreakerOptions } from './circuit-breaker.js'
+export { loadBalancer } from './load-balancer.js'
+export type { LoadBalancerOptions } from './load-balancer.js'

package/src/interceptors/reliability/load-balancer.ts

@@ -0,0 +1,56 @@
+/** loadBalancer (F-REL-04) — weighted round-robin across provider adapters. */
+
+import type { InterceptorContext } from '../../context.js'
+import type { ProviderAdapter } from '../../providers/base.js'
+import type { GavioRequest } from '../../request.js'
+import type { GavioResponse } from '../../response.js'
+import { coerceProvider } from '../../types.js'
+import type { Executor, ExecutorPolicy } from '../base.js'
+
+export interface LoadBalancerOptions {
+  weights?: number[]
+}
+
+class LoadBalancer implements ExecutorPolicy {
+  readonly name = 'load_balancer'
+  readonly isExecutorPolicy = true as const
+
+  private readonly pool: ProviderAdapter[]
+  private index = 0
+
+  constructor(adapters: ProviderAdapter[], options: LoadBalancerOptions = {}) {
+    if (adapters.length === 0) {
+      throw new Error('loadBalancer requires at least one adapter')
+    }
+    const weights = options.weights ?? adapters.map(() => 1)
+    if (weights.length !== adapters.length) {
+      throw new Error('weights must match adapters length')
+    }
+    // Expand by weight, then cycle for round-robin.
+    this.pool = []
+    adapters.forEach((adapter, i) => {
+      for (let k = 0; k < Math.max(1, weights[i]!); k++) this.pool.push(adapter)
+    })
+  }
+
+  async around(
+    request: GavioRequest,
+    ctx: InterceptorContext,
+    _callNext: Executor,
+  ): Promise<GavioResponse> {
+    ctx.markFired(this.name)
+    const adapter = this.pool[this.index % this.pool.length]!
+    this.index += 1
+    const rerouted = request.copyWithMessages(request.messages)
+    rerouted.provider = coerceProvider(adapter.providerName)
+    return adapter.complete(rerouted)
+  }
+}
+
+/** Factory: build a load balancer over a pool of adapters. */
+export function loadBalancer(
+  adapters: ProviderAdapter[],
+  options: LoadBalancerOptions = {},
+): ExecutorPolicy {
+  return new LoadBalancer(adapters, options)
+}

package/src/pricing.ts

@@ -20,7 +20,11 @@ const DEFAULT_PRICES: Record<string, [number, number]> = {
   'claude-sonnet-4-20250514': [0.003, 0.015],
   'claude-haiku-4-5': [0.0008, 0.004],
   'claude-opus-4-1': [0.015, 0.075],
-  // Local / mock are free.
+  // Gemini (approximate public pricing; override via config)
+  'gemini-2.0-flash': [0.0001, 0.0004],
+  'gemini-1.5-flash': [0.000075, 0.0003],
+  'gemini-1.5-pro': [0.00125, 0.005],
+  // Local (Ollama) / mock are free.
   mock: [0.0, 0.0],
 }
 

package/src/providers/azure-openai.ts

@@ -0,0 +1,77 @@
+/** azureOpenaiAdapter — Azure OpenAI deployment-based chat completions. */
+
+import { ConfigurationError } from '../errors.js'
+import type { PricingProvider } from '../pricing.js'
+import type { GavioRequest } from '../request.js'
+import type { GavioResponse } from '../response.js'
+import { TokenUsage } from '../types.js'
+import { BaseProviderAdapter } from './base.js'
+import { postJson } from './http.js'
+
+const DEFAULT_API_VERSION = '2024-06-01'
+
+export interface AzureOpenAIAdapterOptions {
+  apiKey?: string
+  endpoint?: string
+  deployment?: string
+  apiVersion?: string
+  timeoutMs?: number
+  pricing?: PricingProvider
+}
+
+class AzureOpenAIAdapter extends BaseProviderAdapter {
+  private readonly apiKey: string | undefined
+  readonly endpoint: string
+  private readonly deployment: string | undefined
+  private readonly apiVersion: string
+  private readonly timeoutSeconds: number
+
+  constructor(options: AzureOpenAIAdapterOptions = {}) {
+    super(options.pricing)
+    this.apiKey = options.apiKey ?? process.env['AZURE_OPENAI_API_KEY']
+    this.endpoint = (options.endpoint ?? process.env['AZURE_OPENAI_ENDPOINT'] ?? '').replace(
+      /\/+$/,
+      '',
+    )
+    this.deployment = options.deployment ?? process.env['AZURE_OPENAI_DEPLOYMENT']
+    this.apiVersion = options.apiVersion ?? DEFAULT_API_VERSION
+    this.timeoutSeconds = (options.timeoutMs ?? 30_000) / 1000
+  }
+
+  get providerName(): string {
+    return 'azure_openai'
+  }
+
+  url(request: GavioRequest): string {
+    const deployment = this.deployment ?? request.model
+    return `${this.endpoint}/openai/deployments/${deployment}/chat/completions?api-version=${this.apiVersion}`
+  }
+
+  async complete(request: GavioRequest): Promise<GavioResponse> {
+    if (!this.apiKey || !this.endpoint) {
+      throw new ConfigurationError('AZURE_OPENAI_API_KEY and AZURE_OPENAI_ENDPOINT must be set')
+    }
+    const started = performance.now()
+    const payload = {
+      messages: request.messages,
+      temperature: request.temperature,
+      max_tokens: request.maxTokens,
+    }
+    const data = await postJson(this.url(request), payload, { 'api-key': this.apiKey }, this.timeoutSeconds)
+    const choices = (data['choices'] as Array<Record<string, unknown>>) ?? []
+    const message = (choices[0]?.['message'] as Record<string, unknown>) ?? {}
+    const content = (message['content'] as string) ?? ''
+    const usageData = (data['usage'] as Record<string, number>) ?? {}
+    const usage = new TokenUsage(usageData['prompt_tokens'] ?? 0, usageData['completion_tokens'] ?? 0)
+    return this.buildResponse(request, content, usage, (data['model'] as string) ?? request.model, started)
+  }
+
+  async healthCheck(): Promise<boolean> {
+    return !!(this.apiKey && this.endpoint)
+  }
+}
+
+/** Factory: build an Azure OpenAI provider adapter. */
+export function azureOpenaiAdapter(options: AzureOpenAIAdapterOptions = {}): AzureOpenAIAdapter {
+  return new AzureOpenAIAdapter(options)
+}

package/src/providers/gemini.ts

@@ -0,0 +1,95 @@
+/** geminiAdapter — Google Generative Language API (generateContent). */
+
+import { ConfigurationError } from '../errors.js'
+import type { PricingProvider } from '../pricing.js'
+import type { GavioRequest } from '../request.js'
+import type { GavioResponse } from '../response.js'
+import { TokenUsage, type Message } from '../types.js'
+import { BaseProviderAdapter } from './base.js'
+import { postJson } from './http.js'
+
+const DEFAULT_BASE_URL = 'https://generativelanguage.googleapis.com/v1beta'
+
+export interface GeminiAdapterOptions {
+  apiKey?: string
+  baseUrl?: string
+  timeoutMs?: number
+  pricing?: PricingProvider
+}
+
+interface GeminiContent {
+  role: string
+  parts: { text: string }[]
+}
+
+/** Map Gavio messages to Gemini contents + a system instruction. */
+export function geminiToContents(messages: Message[]): {
+  system: string | null
+  contents: GeminiContent[]
+} {
+  let system: string | null = null
+  const contents: GeminiContent[] = []
+  for (const m of messages) {
+    const text = m.content
+    if (m.role === 'system') {
+      system = system ? `${system}\n${text}` : text
+      continue
+    }
+    contents.push({ role: m.role === 'assistant' ? 'model' : 'user', parts: [{ text }] })
+  }
+  return { system, contents }
+}
+
+class GeminiAdapter extends BaseProviderAdapter {
+  private readonly apiKey: string | undefined
+  private readonly baseUrl: string
+  private readonly timeoutSeconds: number
+
+  constructor(options: GeminiAdapterOptions = {}) {
+    super(options.pricing)
+    this.apiKey =
+      options.apiKey ?? process.env['GEMINI_API_KEY'] ?? process.env['GOOGLE_API_KEY']
+    this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, '')
+    this.timeoutSeconds = (options.timeoutMs ?? 30_000) / 1000
+  }
+
+  get providerName(): string {
+    return 'gemini'
+  }
+
+  private payload(request: GavioRequest): Record<string, unknown> {
+    const { system, contents } = geminiToContents(request.messages)
+    const payload: Record<string, unknown> = {
+      contents,
+      generationConfig: {
+        temperature: request.temperature,
+        maxOutputTokens: request.maxTokens,
+      },
+    }
+    if (system) payload['systemInstruction'] = { parts: [{ text: system }] }
+    return payload
+  }
+
+  async complete(request: GavioRequest): Promise<GavioResponse> {
+    if (!this.apiKey) throw new ConfigurationError('GEMINI_API_KEY not set')
+    const started = performance.now()
+    const url = `${this.baseUrl}/models/${request.model}:generateContent?key=${this.apiKey}`
+    const data = await postJson(url, this.payload(request), {}, this.timeoutSeconds)
+    const candidates = (data['candidates'] as Array<Record<string, unknown>>) ?? [{}]
+    const contentObj = (candidates[0]?.['content'] as Record<string, unknown>) ?? {}
+    const parts = (contentObj['parts'] as Array<{ text?: string }>) ?? []
+    const content = parts.map((p) => p.text ?? '').join('')
+    const um = (data['usageMetadata'] as Record<string, number>) ?? {}
+    const usage = new TokenUsage(um['promptTokenCount'] ?? 0, um['candidatesTokenCount'] ?? 0)
+    return this.buildResponse(request, content, usage, request.model, started)
+  }
+
+  async healthCheck(): Promise<boolean> {
+    return !!this.apiKey
+  }
+}
+
+/** Factory: build a Gemini provider adapter. */
+export function geminiAdapter(options: GeminiAdapterOptions = {}): GeminiAdapter {
+  return new GeminiAdapter(options)
+}

package/src/providers/index.ts

@@ -4,8 +4,11 @@ import { ConfigurationError } from '../errors.js'
 import type { PricingProvider } from '../pricing.js'
 import { Provider, coerceProvider } from '../types.js'
 import { anthropicAdapter } from './anthropic.js'
+import { azureOpenaiAdapter } from './azure-openai.js'
 import type { ProviderAdapter } from './base.js'
+import { geminiAdapter } from './gemini.js'
 import { mockProvider } from './mock.js'
+import { ollamaAdapter } from './ollama.js'
 import { openaiAdapter } from './openai.js'
 
 export type { ProviderAdapter } from './base.js'
@@ -16,24 +19,37 @@ export { openaiAdapter } from './openai.js'
 export type { OpenAIAdapterOptions } from './openai.js'
 export { anthropicAdapter } from './anthropic.js'
 export type { AnthropicAdapterOptions } from './anthropic.js'
+export { geminiAdapter } from './gemini.js'
+export type { GeminiAdapterOptions } from './gemini.js'
+export { azureOpenaiAdapter } from './azure-openai.js'
+export type { AzureOpenAIAdapterOptions } from './azure-openai.js'
+export { ollamaAdapter } from './ollama.js'
+export type { OllamaAdapterOptions } from './ollama.js'
 export { Provider } from '../types.js'
 
-/** Instantiate the default adapter for a provider id. v0.1.0: OpenAI, Anthropic, Mock. */
+/** Instantiate the default adapter for a provider id. */
 export function buildAdapter(
   provider: Provider | string,
   pricing?: PricingProvider,
 ): ProviderAdapter {
   const p = coerceProvider(provider)
+  const opts = pricing ? { pricing } : {}
   switch (p) {
     case Provider.OPENAI:
-      return openaiAdapter(pricing ? { pricing } : {})
+      return openaiAdapter(opts)
     case Provider.ANTHROPIC:
-      return anthropicAdapter(pricing ? { pricing } : {})
+      return anthropicAdapter(opts)
+    case Provider.GEMINI:
+      return geminiAdapter(opts)
+    case Provider.AZURE_OPENAI:
+      return azureOpenaiAdapter(opts)
+    case Provider.OLLAMA:
+      return ollamaAdapter(opts)
     case Provider.MOCK:
-      return mockProvider(pricing ? { pricing } : {})
+      return mockProvider(opts)
     default:
       throw new ConfigurationError(
-        `Provider '${p}' is not available in v0.1.0 (available: openai, anthropic, mock)`,
+        `Provider '${p}' is not available (v0.3.0 adds bedrock, cohere)`,
       )
   }
 }

package/src/providers/ollama.ts

@@ -0,0 +1,61 @@
+/** ollamaAdapter — local models via the Ollama chat API. */
+
+import type { PricingProvider } from '../pricing.js'
+import type { GavioRequest } from '../request.js'
+import type { GavioResponse } from '../response.js'
+import { TokenUsage } from '../types.js'
+import { BaseProviderAdapter } from './base.js'
+import { postJson } from './http.js'
+
+const DEFAULT_BASE_URL = 'http://localhost:11434'
+
+export interface OllamaAdapterOptions {
+  baseUrl?: string
+  timeoutMs?: number
+  pricing?: PricingProvider
+}
+
+class OllamaAdapter extends BaseProviderAdapter {
+  private readonly baseUrl: string
+  private readonly timeoutSeconds: number
+
+  constructor(options: OllamaAdapterOptions = {}) {
+    super(options.pricing)
+    this.baseUrl = (options.baseUrl ?? process.env['OLLAMA_HOST'] ?? DEFAULT_BASE_URL).replace(
+      /\/+$/,
+      '',
+    )
+    this.timeoutSeconds = (options.timeoutMs ?? 60_000) / 1000
+  }
+
+  get providerName(): string {
+    return 'ollama'
+  }
+
+  async complete(request: GavioRequest): Promise<GavioResponse> {
+    const started = performance.now()
+    const payload = {
+      model: request.model,
+      messages: request.messages,
+      stream: false,
+      options: { temperature: request.temperature },
+    }
+    const data = await postJson(`${this.baseUrl}/api/chat`, payload, {}, this.timeoutSeconds)
+    const message = (data['message'] as Record<string, unknown>) ?? {}
+    const content = (message['content'] as string) ?? ''
+    const usage = new TokenUsage(
+      (data['prompt_eval_count'] as number) ?? 0,
+      (data['eval_count'] as number) ?? 0,
+    )
+    return this.buildResponse(request, content, usage, (data['model'] as string) ?? request.model, started)
+  }
+
+  async healthCheck(): Promise<boolean> {
+    return true
+  }
+}
+
+/** Factory: build an Ollama provider adapter. */
+export function ollamaAdapter(options: OllamaAdapterOptions = {}): OllamaAdapter {
+  return new OllamaAdapter(options)
+}

package/src/shim/openai.ts

@@ -0,0 +1,76 @@
+/**
+ * OpenAI drop-in shim (F-DX-04) — point existing OpenAI SDK code at Gavio.
+ *
+ *   import { Gateway } from 'gavio'
+ *   import { GavioOpenAI } from 'gavio/shim/openai'
+ *
+ *   const client = new GavioOpenAI(new Gateway({ provider: 'openai', model: 'gpt-4o' }))
+ *   const resp = await client.chat.completions.create({
+ *     model: 'gpt-4o', messages: [{ role: 'user', content: 'hi' }],
+ *   })
+ *   console.log(resp.choices[0].message.content)
+ */
+
+import type { Gateway } from '../gateway.js'
+import type { GavioResponse } from '../response.js'
+import type { Message } from '../types.js'
+
+export interface ChatCompletion {
+  id: string
+  object: 'chat.completion'
+  model: string
+  choices: { index: number; message: { role: string; content: string }; finish_reason: string }[]
+  usage: { prompt_tokens: number; completion_tokens: number; total_tokens: number }
+  gavio: { costUsd: number; cacheHit: boolean; interceptorsFired: string[] }
+}
+
+export interface CreateParams {
+  messages: Message[]
+  model?: string
+  temperature?: number
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  max_tokens?: number
+}
+
+function toCompletion(resp: GavioResponse): ChatCompletion {
+  return {
+    id: resp.traceId,
+    object: 'chat.completion',
+    model: resp.modelVersion || resp.model,
+    choices: [
+      { index: 0, message: { role: 'assistant', content: resp.content }, finish_reason: 'stop' },
+    ],
+    usage: {
+      prompt_tokens: resp.usage.promptTokens,
+      completion_tokens: resp.usage.completionTokens,
+      total_tokens: resp.usage.totalTokens,
+    },
+    gavio: {
+      costUsd: resp.costUsd,
+      cacheHit: resp.cacheHit,
+      interceptorsFired: resp.interceptorsFired,
+    },
+  }
+}
+
+class Completions {
+  constructor(private readonly gw: Gateway) {}
+
+  async create(params: CreateParams): Promise<ChatCompletion> {
+    const resp = await this.gw.complete({
+      messages: params.messages,
+      model: params.model,
+      options: { temperature: params.temperature ?? 0.7, maxTokens: params.max_tokens ?? 1024 },
+    })
+    return toCompletion(resp)
+  }
+}
+
+/** OpenAI-client-shaped facade over a Gavio Gateway. */
+export class GavioOpenAI {
+  readonly chat: { completions: Completions }
+
+  constructor(gateway: Gateway) {
+    this.chat = { completions: new Completions(gateway) }
+  }
+}