gavio 0.1.0 → 0.3.0

package/src/interceptors/quality/risk.ts

@@ -0,0 +1,64 @@
+/**
+ * RiskScorer (F-QUA-06) — a composite risk score from per-request signals.
+ *
+ * Folds the signals other interceptors leave on the {@link InterceptorContext}
+ * — PII entities found, guardrail outcome, and the prompt-injection risk — into
+ * a single score in `[0, 1]` written to `ctx.riskScore` (and thus the audit
+ * record). Register it *inside* the audit interceptor so audit sees the composite.
+ */
+
+import type { InterceptorContext } from '../../context.js'
+import type { GavioResponse } from '../../response.js'
+import type { Interceptor } from '../base.js'
+
+export interface RiskWeights {
+  pii?: number
+  guardrail?: number
+  injection?: number
+  /** PII entity count at which the PII signal saturates to 1.0 (<= 0 → any PII = 1.0). */
+  piiSaturation?: number
+}
+
+// Guardrail outcome → its contribution before weighting.
+const GUARDRAIL_SIGNAL: Record<string, number> = { FAIL: 1.0, HITL: 0.6 }
+
+export class RiskScorer implements Interceptor {
+  readonly name = 'risk_scorer'
+  readonly dryRunSafe = true
+
+  private readonly pii: number
+  private readonly guardrail: number
+  private readonly injection: number
+  private readonly piiSaturation: number
+
+  constructor(weights: RiskWeights = {}) {
+    this.pii = weights.pii ?? 0.3
+    this.guardrail = weights.guardrail ?? 0.4
+    this.injection = weights.injection ?? 0.3
+    this.piiSaturation = weights.piiSaturation ?? 4
+  }
+
+  /** Compute the composite risk score from the three raw signals. */
+  score(piiCount: number, guardrailOutcome: string | null, injectionScore: number | null): number {
+    let piiSignal = 0
+    if (piiCount > 0) {
+      piiSignal = this.piiSaturation <= 0 ? 1 : Math.min(1, piiCount / this.piiSaturation)
+    }
+    const guardrailSignal = GUARDRAIL_SIGNAL[guardrailOutcome ?? ''] ?? 0
+    const injectionSignal = injectionScore ?? 0
+    const composite =
+      this.pii * piiSignal + this.guardrail * guardrailSignal + this.injection * injectionSignal
+    return Math.max(0, Math.min(1, composite))
+  }
+
+  async after(response: GavioResponse, ctx: InterceptorContext): Promise<GavioResponse> {
+    const piiCount = Object.values(ctx.piiEntityCounts).reduce((a, b) => a + b, 0)
+    ctx.riskScore = this.score(piiCount, ctx.guardrailOutcome, ctx.riskScore)
+    return response
+  }
+}
+
+/** Build a risk scorer. */
+export function riskScorer(weights: RiskWeights = {}): RiskScorer {
+  return new RiskScorer(weights)
+}

package/src/interceptors/reliability/circuit-breaker.ts

@@ -0,0 +1,102 @@
+/** circuitBreaker (F-REL-03) — open/half-open/closed state machine. */
+
+import type { InterceptorContext } from '../../context.js'
+import { CircuitOpenError, ProviderError } from '../../errors.js'
+import type { GavioRequest } from '../../request.js'
+import type { GavioResponse } from '../../response.js'
+import type { Executor, ExecutorPolicy } from '../base.js'
+
+export const CircuitState = {
+  CLOSED: 'closed',
+  OPEN: 'open',
+  HALF_OPEN: 'half_open',
+} as const
+export type CircuitState = (typeof CircuitState)[keyof typeof CircuitState]
+
+export interface CircuitBreakerOptions {
+  failureThreshold?: number
+  recoveryTimeoutSeconds?: number
+  halfOpenMaxCalls?: number
+}
+
+class CircuitBreaker implements ExecutorPolicy {
+  readonly name = 'circuit_breaker'
+  readonly isExecutorPolicy = true as const
+
+  private state: CircuitState = CircuitState.CLOSED
+  private failures = 0
+  private openedAt = 0
+  private halfOpenCalls = 0
+
+  private readonly failureThreshold: number
+  private readonly recoveryMs: number
+  private readonly halfOpenMaxCalls: number
+
+  constructor(options: CircuitBreakerOptions = {}) {
+    this.failureThreshold = options.failureThreshold ?? 5
+    this.recoveryMs = (options.recoveryTimeoutSeconds ?? 30) * 1000
+    this.halfOpenMaxCalls = options.halfOpenMaxCalls ?? 2
+  }
+
+  get currentState(): CircuitState {
+    return this.state
+  }
+
+  async around(
+    request: GavioRequest,
+    ctx: InterceptorContext,
+    callNext: Executor,
+  ): Promise<GavioResponse> {
+    ctx.markFired(this.name)
+    this.admit() // throws CircuitOpenError if not allowed through
+    try {
+      const response = await callNext(request)
+      this.onSuccess()
+      return response
+    } catch (error) {
+      if (error instanceof ProviderError) this.onFailure()
+      throw error
+    }
+  }
+
+  private admit(): void {
+    if (this.state === CircuitState.OPEN) {
+      if (Date.now() - this.openedAt >= this.recoveryMs) {
+        this.state = CircuitState.HALF_OPEN
+        this.halfOpenCalls = 0
+      } else {
+        throw new CircuitOpenError('circuit is open')
+      }
+    }
+    if (this.state === CircuitState.HALF_OPEN) {
+      if (this.halfOpenCalls >= this.halfOpenMaxCalls) {
+        throw new CircuitOpenError('circuit half-open probe limit reached')
+      }
+      this.halfOpenCalls += 1
+    }
+  }
+
+  private onSuccess(): void {
+    this.state = CircuitState.CLOSED
+    this.failures = 0
+  }
+
+  private onFailure(): void {
+    if (this.state === CircuitState.HALF_OPEN) {
+      this.trip()
+      return
+    }
+    this.failures += 1
+    if (this.failures >= this.failureThreshold) this.trip()
+  }
+
+  private trip(): void {
+    this.state = CircuitState.OPEN
+    this.openedAt = Date.now()
+  }
+}
+
+/** Factory: build a circuit breaker. */
+export function circuitBreaker(options: CircuitBreakerOptions = {}): ExecutorPolicy {
+  return new CircuitBreaker(options)
+}

package/src/interceptors/reliability/index.ts

@@ -6,3 +6,8 @@ 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'
+export { StreamBuffer } from './stream-buffer.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/interceptors/reliability/stream-buffer.ts

@@ -0,0 +1,27 @@
+/**
+ * StreamBuffer (F-REL-06) — accumulate a provider stream for post-interceptors.
+ *
+ * Post-interceptors (guardrails, PII restore, audit) need the *complete*
+ * response, so a streamed reply is buffered in full before the post pipeline
+ * runs and before any chunk reaches the caller. This trades first-token latency
+ * for the guarantee that every interceptor sees — and can rewrite or block — the
+ * whole response.
+ */
+export class StreamBuffer {
+  private readonly parts: string[] = []
+
+  /** Add one streamed chunk. */
+  append(chunk: string): void {
+    this.parts.push(chunk)
+  }
+
+  /** The full buffered response so far. */
+  text(): string {
+    return this.parts.join('')
+  }
+
+  /** Total buffered length in characters. */
+  get length(): number {
+    return this.parts.reduce((n, p) => n + p.length, 0)
+  }
+}

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/base.ts

@@ -1,6 +1,6 @@
 /** ProviderAdapter interface and shared response-building helpers. */
 
-import { PricingProvider } from '../pricing.js'
+import { PricingProvider, estimateTokens } from '../pricing.js'
 import { GavioRequest } from '../request.js'
 import { GavioResponse } from '../response.js'
 import { TokenUsage } from '../types.js'
@@ -10,6 +10,8 @@ export interface ProviderAdapter {
   readonly providerName: string
   complete(request: GavioRequest): Promise<GavioResponse>
   stream?(request: GavioRequest): AsyncIterable<string>
+  /** Build a response from a fully buffered stream (F-REL-06). */
+  buildStreamResponse?(request: GavioRequest, content: string, startedAt: number): GavioResponse
   healthCheck(): Promise<boolean>
   readonly reportedModelVersion?: string | null
 }
@@ -30,6 +32,24 @@ export abstract class BaseProviderAdapter implements ProviderAdapter {
     return null
   }
 
+  /**
+   * Build a response from a fully buffered stream (F-REL-06). Streamed chunks
+   * carry text only, so token usage is estimated from prompt + content.
+   */
+  buildStreamResponse(request: GavioRequest, content: string, startedAt: number): GavioResponse {
+    const usage = new TokenUsage(
+      estimateTokens(request.promptText()),
+      estimateTokens(content),
+    )
+    return this.buildResponse(
+      request,
+      content,
+      usage,
+      this.reportedModelVersion ?? request.model,
+      startedAt,
+    )
+  }
+
   protected buildResponse(
     request: GavioRequest,
     content: string,

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/request.ts

@@ -1,8 +1,8 @@
 /** GavioRequest — the canonical, provider-agnostic request model. */
 
 import { newTraceId } from './ids.js'
-import { coerceProvider } from './types.js'
-import type { Message, Provider } from './types.js'
+import { coerceProvider, PromptLineage } from './types.js'
+import type { Message, PromptLineageInit, Provider } from './types.js'
 
 export interface GavioRequestInit {
   messages: Message[]
@@ -14,6 +14,7 @@ export interface GavioRequestInit {
   sessionId?: string | null
   options?: Record<string, unknown>
   metadata?: Record<string, unknown>
+  lineage?: PromptLineage | PromptLineageInit | null
 }
 
 /**
@@ -31,6 +32,7 @@ export class GavioRequest {
   sessionId: string | null
   options: Record<string, unknown>
   metadata: Record<string, unknown>
+  lineage: PromptLineage | null
 
   constructor(init: GavioRequestInit) {
     this.messages = init.messages
@@ -42,6 +44,7 @@ export class GavioRequest {
     this.sessionId = init.sessionId ?? null
     this.options = init.options ?? {}
     this.metadata = init.metadata ?? {}
+    this.lineage = init.lineage != null ? PromptLineage.from(init.lineage) : null
   }
 
   get temperature(): number {
@@ -71,6 +74,7 @@ export class GavioRequest {
       sessionId: this.sessionId,
       options: { ...this.options },
       metadata: { ...this.metadata },
+      lineage: this.lineage,
     })
   }
 }