@strav/brain 0.4.30 → 1.0.0-alpha.8

package/src/memory/token_counter.ts

@@ -1,101 +0,0 @@
-import type { Message, ContentBlock } from '../types.ts'
-
-/** Known context window sizes by model identifier. */
-const MODEL_CONTEXT_WINDOWS: Record<string, number> = {
-  // Anthropic
-  'claude-opus-4-20250514': 200_000,
-  'claude-sonnet-4-20250514': 200_000,
-  'claude-sonnet-4-5-20250514': 200_000,
-  'claude-haiku-3-5-20241022': 200_000,
-
-  // OpenAI
-  'gpt-4o': 128_000,
-  'gpt-4o-mini': 128_000,
-  'gpt-4-turbo': 128_000,
-  'gpt-4.1': 1_000_000,
-  'gpt-4.1-mini': 1_000_000,
-  'gpt-4.1-nano': 1_000_000,
-  o3: 200_000,
-  'o3-mini': 200_000,
-  'o4-mini': 200_000,
-
-  // DeepSeek
-  'deepseek-chat': 64_000,
-  'deepseek-reasoner': 64_000,
-}
-
-const DEFAULT_CONTEXT_WINDOW = 128_000
-
-/** Overhead tokens per message (role, formatting, separators). */
-const MESSAGE_OVERHEAD = 4
-
-/** Average characters per token for estimation. */
-const CHARS_PER_TOKEN = 4
-
-/**
- * Approximate token counting without external dependencies.
- *
- * Uses character-based estimation (~4 chars per token) which is
- * conservative enough for budget management. Exact counts are not
- * needed — we just need to know when we're approaching the limit.
- */
-export class TokenCounter {
-  /** Estimate token count for a string. */
-  static estimate(text: string): number {
-    if (!text) return 0
-    return Math.ceil(text.length / CHARS_PER_TOKEN)
-  }
-
-  /** Estimate token count for a Message array. */
-  static estimateMessages(messages: Message[]): number {
-    let total = 0
-
-    for (const msg of messages) {
-      total += MESSAGE_OVERHEAD
-      total += TokenCounter.estimateContent(msg.content)
-
-      if (msg.toolCalls) {
-        for (const call of msg.toolCalls) {
-          total += TokenCounter.estimate(call.name)
-          total += TokenCounter.estimate(JSON.stringify(call.arguments))
-          total += MESSAGE_OVERHEAD
-        }
-      }
-    }
-
-    return total
-  }
-
-  /** Get the context window size for a model, or the default fallback. */
-  static contextWindow(model: string): number {
-    // Exact match
-    if (MODEL_CONTEXT_WINDOWS[model] !== undefined) {
-      return MODEL_CONTEXT_WINDOWS[model]!
-    }
-
-    // Prefix match (e.g. 'claude-sonnet-4-20250514' matches 'claude-sonnet-4')
-    for (const [key, size] of Object.entries(MODEL_CONTEXT_WINDOWS)) {
-      if (model.startsWith(key) || key.startsWith(model)) {
-        return size
-      }
-    }
-
-    return DEFAULT_CONTEXT_WINDOW
-  }
-
-  /** Estimate tokens for message content (string or ContentBlock[]). */
-  private static estimateContent(content: string | ContentBlock[]): number {
-    if (typeof content === 'string') {
-      return TokenCounter.estimate(content)
-    }
-
-    let total = 0
-    for (const block of content) {
-      if (block.text) total += TokenCounter.estimate(block.text)
-      if (block.content) total += TokenCounter.estimate(block.content)
-      if (block.input) total += TokenCounter.estimate(JSON.stringify(block.input))
-      if (block.name) total += TokenCounter.estimate(block.name)
-    }
-    return total
-  }
-}

package/src/memory/types.ts

@@ -1,68 +0,0 @@
-import type { Message } from '../types.ts'
-
-// ── Configuration ───────────────────────────────────────────────────────────
-
-export interface MemoryConfig {
-  /** Max tokens for the entire context window (default: auto-detect from model). */
-  maxContextTokens?: number
-  /** Strategy: 'sliding_window' | 'summarize' (default: 'summarize'). */
-  strategy?: string
-  /** Reserve this fraction of context for the response (default: 0.25). */
-  responseReserve?: number
-  /** Min messages to keep in working memory before compacting (default: 4). */
-  minWorkingMessages?: number
-  /** Number of oldest messages to compact per cycle (default: 10). */
-  compactionBatchSize?: number
-  /** Enable semantic fact extraction during compaction (default: true). */
-  extractFacts?: boolean
-}
-
-// ── Compaction Strategy ─────────────────────────────────────────────────────
-
-export interface CompactionResult {
-  /** Summary text replacing the compacted messages. */
-  summary: string
-  /** Facts extracted during compaction (if enabled). */
-  facts?: Fact[]
-  /** Token count of the summary. */
-  summaryTokens: number
-}
-
-export interface CompactionStrategy {
-  readonly name: string
-  compact(
-    messages: Message[],
-    options: { provider: string; model: string; existingSummary?: string; extractFacts?: boolean }
-  ): Promise<CompactionResult>
-}
-
-// ── Thread Store ────────────────────────────────────────────────────────────
-
-export interface SerializedMemoryThread {
-  id: string
-  messages: Message[]
-  system?: string
-  summary?: string
-  facts?: Fact[]
-  metadata?: Record<string, unknown>
-  createdAt: string
-  updatedAt: string
-}
-
-export interface ThreadStore {
-  save(thread: SerializedMemoryThread): Promise<void>
-  load(id: string): Promise<SerializedMemoryThread | null>
-  delete(id: string): Promise<void>
-  list(options?: { limit?: number; offset?: number }): Promise<SerializedMemoryThread[]>
-}
-
-// ── Semantic Memory ─────────────────────────────────────────────────────────
-
-export interface Fact {
-  key: string
-  value: string
-  source: 'extracted' | 'explicit'
-  confidence: number
-  createdAt: string
-  updatedAt: string
-}

package/src/providers/google_provider.ts

@@ -1,496 +0,0 @@
-import { parseSSE } from '../utils/sse_parser.ts'
-import { retryableFetch, type RetryOptions } from '../utils/retry.ts'
-import { ExternalServiceError } from '@strav/kernel'
-import type {
-  AIProvider,
-  CompletionRequest,
-  CompletionResponse,
-  StreamChunk,
-  EmbeddingResponse,
-  ProviderConfig,
-  Message,
-  ToolCall,
-  TranscribeRequest,
-  TranscriptionResponse,
-  Usage,
-} from '../types.ts'
-
-/**
- * Google Gemini API provider.
- *
- * Translates the framework's normalized CompletionRequest/Response
- * to/from the Google Generative Language API wire format. Uses raw `fetch()`.
- */
-export class GoogleProvider implements AIProvider {
-  readonly name: string
-  private apiKey: string
-  private baseUrl: string
-  private defaultModel: string
-  private defaultMaxTokens?: number
-  private retryOptions: RetryOptions
-  private toolCallIdToNameMap: Map<string, string> = new Map()
-
-  constructor(config: ProviderConfig) {
-    this.name = 'google'
-    this.apiKey = config.apiKey
-    this.baseUrl = (config.baseUrl ?? 'https://generativelanguage.googleapis.com/v1beta').replace(/\/$/, '')
-    this.defaultModel = config.model || 'gemini-2.0-flash'
-    this.defaultMaxTokens = config.maxTokens
-    this.retryOptions = {
-      maxRetries: config.maxRetries ?? 3,
-      baseDelay: config.retryBaseDelay ?? 1000,
-    }
-  }
-
-  async complete(request: CompletionRequest): Promise<CompletionResponse> {
-    const model = request.model ?? this.defaultModel
-    const body = this.buildRequestBody(request, false)
-
-    const response = await retryableFetch(
-      'Google',
-      `${this.baseUrl}/models/${model}:generateContent`,
-      { method: 'POST', headers: this.buildHeaders(), body: JSON.stringify(body) },
-      this.retryOptions
-    )
-
-    const data: any = await response.json()
-    return this.parseResponse(data)
-  }
-
-  async *stream(request: CompletionRequest): AsyncIterable<StreamChunk> {
-    const model = request.model ?? this.defaultModel
-    const body = this.buildRequestBody(request, true)
-
-    const response = await retryableFetch(
-      'Google',
-      `${this.baseUrl}/models/${model}:streamGenerateContent`,
-      { method: 'POST', headers: this.buildHeaders(), body: JSON.stringify(body) },
-      this.retryOptions
-    )
-
-    if (!response.body) {
-      throw new ExternalServiceError('Google', undefined, 'No stream body returned')
-    }
-
-    let currentToolIndex = -1
-    let currentToolCall: Partial<ToolCall> | null = null
-
-    for await (const sse of parseSSE(response.body)) {
-      if (sse.data === '[DONE]') {
-        yield { type: 'done' }
-        break
-      }
-
-      let parsed: any
-      try {
-        parsed = JSON.parse(sse.data)
-      } catch {
-        continue
-      }
-
-      const candidate = parsed.candidates?.[0]
-      if (!candidate) continue
-
-      // Process content parts if they exist
-      if (candidate.content?.parts) {
-        for (const part of candidate.content.parts) {
-          if (part.text) {
-            // Text content
-            yield { type: 'text', text: part.text }
-          } else if (part.functionCall) {
-            // Function call
-            if (currentToolCall === null) {
-              // Start of new tool call
-              currentToolIndex++
-              currentToolCall = {
-                id: part.functionCall.id || this.generateToolCallId(),
-                name: part.functionCall.name,
-                arguments: part.functionCall.args || {}
-              }
-
-              yield {
-                type: 'tool_start',
-                toolCall: {
-                  id: currentToolCall.id,
-                  name: currentToolCall.name
-                } as ToolCall,
-                toolIndex: currentToolIndex,
-              }
-            }
-
-            // If this is a complete function call, end it
-            if (part.functionCall.name && part.functionCall.args) {
-              yield { type: 'tool_end', toolIndex: currentToolIndex }
-              currentToolCall = null
-            }
-          }
-        }
-      }
-
-      // Check if this is the final chunk
-      if (candidate.finishReason) {
-        // Handle usage information in the final chunk
-        if (parsed.usageMetadata) {
-          const usage: Usage = {
-            inputTokens: parsed.usageMetadata.promptTokenCount ?? 0,
-            outputTokens: parsed.usageMetadata.candidatesTokenCount ?? 0,
-            totalTokens: parsed.usageMetadata.totalTokenCount ?? 0,
-          }
-          yield { type: 'usage', usage }
-        }
-
-        yield { type: 'done' }
-        break
-      }
-    }
-  }
-
-  async embed(input: string | string[], model?: string): Promise<EmbeddingResponse> {
-    const embeddingModel = model ?? 'text-embedding-004'
-    const inputs = Array.isArray(input) ? input : [input]
-
-    const requests = inputs.map(text => ({
-      model: `models/${embeddingModel}`,
-      content: {
-        parts: [{ text }]
-      }
-    }))
-
-    const embeddings: number[][] = []
-
-    // Process each input separately as Google's batch API might not be available
-    for (const request of requests) {
-      const response = await retryableFetch(
-        'Google',
-        `${this.baseUrl}/models/${embeddingModel}:embedContent`,
-        { method: 'POST', headers: this.buildHeaders(), body: JSON.stringify(request) },
-        this.retryOptions
-      )
-
-      const data: any = await response.json()
-      if (data.embedding?.values) {
-        embeddings.push(data.embedding.values)
-      }
-    }
-
-    return {
-      embeddings,
-      model: embeddingModel,
-      usage: { totalTokens: inputs.length * 10 } // Rough estimate, Google doesn't provide token count for embeddings
-    }
-  }
-
-  /**
-   * Speech-to-text via Gemini's multimodal generateContent endpoint.
-   *
-   * Gemini doesn't have a dedicated STT endpoint; instead, audio is
-   * passed as an inline `audio/*` part alongside a text prompt asking
-   * for a transcription. We default to `gemini-2.5-flash` (fast, cheap,
-   * Thai-capable). Override `model` for `gemini-2.5-pro` when accuracy
-   * matters more than latency.
-   *
-   * Inline audio is capped at ~20MB across the whole request. Chunk
-   * longer recordings, or use Gemini's Files API (upload + reference)
-   * which isn't covered here — out of scope for the typical SME
-   * voice-note flow (<=60s clips).
-   */
-  async transcribe(request: TranscribeRequest): Promise<TranscriptionResponse> {
-    const model = request.model ?? 'gemini-2.5-flash'
-    const contentType = request.contentType ?? 'audio/mpeg'
-
-    const bytes =
-      request.audio instanceof Blob
-        ? new Uint8Array(await request.audio.arrayBuffer())
-        : request.audio
-    const base64 = encodeBase64(bytes)
-
-    const instruction = buildTranscriptionInstruction(request)
-
-    const body = {
-      contents: [
-        {
-          role: 'user',
-          parts: [
-            { text: instruction },
-            { inline_data: { mime_type: contentType, data: base64 } },
-          ],
-        },
-      ],
-      generationConfig: {
-        // Deterministic output for a transcription task.
-        temperature: 0,
-      },
-    }
-
-    const response = await retryableFetch(
-      'Google',
-      `${this.baseUrl}/models/${model}:generateContent`,
-      { method: 'POST', headers: this.buildHeaders(), body: JSON.stringify(body) },
-      this.retryOptions
-    )
-
-    const data: any = await response.json()
-    const text = extractTranscript(data)
-
-    return {
-      text,
-      language: request.language,
-      raw: data,
-    }
-  }
-
-  // ── Private helpers ──────────────────────────────────────────────────────
-
-  private buildHeaders(): Record<string, string> {
-    return {
-      'content-type': 'application/json',
-      'x-goog-api-key': this.apiKey,
-    }
-  }
-
-  private buildRequestBody(request: CompletionRequest, stream: boolean): Record<string, unknown> {
-    const model = request.model ?? this.defaultModel
-
-    const body: Record<string, unknown> = {
-      contents: this.mapMessages(request.messages),
-    }
-
-    // Add system instruction if present
-    if (request.system) {
-      body.systemInstruction = {
-        parts: [{ text: request.system }]
-      }
-    }
-
-    // Generation config
-    const generationConfig: Record<string, unknown> = {}
-
-    if (request.maxTokens !== undefined) {
-      generationConfig.maxOutputTokens = request.maxTokens
-    } else if (this.defaultMaxTokens !== undefined) {
-      generationConfig.maxOutputTokens = this.defaultMaxTokens
-    }
-
-    if (request.temperature !== undefined) {
-      generationConfig.temperature = request.temperature
-    }
-
-    if (request.stopSequences?.length) {
-      generationConfig.stopSequences = request.stopSequences
-    }
-
-    // Structured output
-    if (request.schema) {
-      generationConfig.responseMimeType = 'application/json'
-      generationConfig.responseSchema = request.schema
-    }
-
-    if (Object.keys(generationConfig).length > 0) {
-      body.generationConfig = generationConfig
-    }
-
-    // Tools (function declarations)
-    if (request.tools?.length) {
-      body.tools = [{
-        functionDeclarations: request.tools.map(t => ({
-          name: t.name,
-          description: t.description,
-          parameters: t.parameters,
-        }))
-      }]
-
-      // Tool choice configuration
-      if (request.toolChoice) {
-        const toolConfig: Record<string, unknown> = {}
-
-        if (request.toolChoice === 'auto') {
-          toolConfig.functionCallingConfig = { mode: 'AUTO' }
-        } else if (request.toolChoice === 'required') {
-          toolConfig.functionCallingConfig = { mode: 'ANY' }
-        } else if (typeof request.toolChoice === 'object' && request.toolChoice.name) {
-          toolConfig.functionCallingConfig = {
-            mode: 'ANY',
-            allowedFunctionNames: [request.toolChoice.name]
-          }
-        }
-
-        if (Object.keys(toolConfig).length > 0) {
-          body.toolConfig = toolConfig
-        }
-      }
-    }
-
-    return body
-  }
-
-  private mapMessages(messages: Message[]): any[] {
-    const result: any[] = []
-
-    for (const msg of messages) {
-      if (msg.role === 'tool') {
-        // Tool results go as user messages with function response parts
-        // Get the function name from our mapping
-        const functionName = msg.toolCallId ? this.toolCallIdToNameMap.get(msg.toolCallId) : undefined
-
-        if (!functionName) {
-          throw new ExternalServiceError('Google', undefined, `No function name found for tool call ID: ${msg.toolCallId}`)
-        }
-
-        result.push({
-          role: 'user',
-          parts: [
-            {
-              functionResponse: {
-                name: functionName,
-                response: {
-                  content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
-                }
-              }
-            }
-          ]
-        })
-      } else if (msg.role === 'assistant') {
-        const parts: any[] = []
-
-        // Add text content if present
-        const text = typeof msg.content === 'string' ? msg.content : ''
-        if (text) {
-          parts.push({ text })
-        }
-
-        // Add function call parts and track their IDs
-        if (msg.toolCalls?.length) {
-          for (const tc of msg.toolCalls) {
-            // Store the mapping for later use
-            this.toolCallIdToNameMap.set(tc.id, tc.name)
-
-            parts.push({
-              functionCall: {
-                name: tc.name,
-                args: tc.arguments,
-              }
-            })
-          }
-        }
-
-        result.push({
-          role: 'model', // Gemini uses 'model' instead of 'assistant'
-          parts
-        })
-      } else {
-        // User messages
-        result.push({
-          role: 'user',
-          parts: [{ text: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content) }]
-        })
-      }
-    }
-
-    return result
-  }
-
-  private parseResponse(data: any): CompletionResponse {
-    const candidate = data.candidates?.[0]
-    if (!candidate) {
-      throw new ExternalServiceError('Google', undefined, 'No candidates in response')
-    }
-
-    let content = ''
-    const toolCalls: ToolCall[] = []
-
-    // Extract content from parts
-    if (Array.isArray(candidate.content?.parts)) {
-      for (const part of candidate.content.parts) {
-        if (part.text) {
-          content += part.text
-        } else if (part.functionCall) {
-          toolCalls.push({
-            id: part.functionCall.id || this.generateToolCallId(),
-            name: part.functionCall.name,
-            arguments: part.functionCall.args || {},
-          })
-        }
-      }
-    }
-
-    const usage: Usage = {
-      inputTokens: data.usageMetadata?.promptTokenCount ?? 0,
-      outputTokens: data.usageMetadata?.candidatesTokenCount ?? 0,
-      totalTokens: data.usageMetadata?.totalTokenCount ?? 0,
-    }
-
-    let stopReason: CompletionResponse['stopReason'] = 'end'
-
-    // Check tool calls first, as Google may return STOP even with tool calls
-    if (toolCalls.length > 0) {
-      stopReason = 'tool_use'
-    } else {
-      switch (candidate.finishReason) {
-        case 'STOP':
-          stopReason = 'end'
-          break
-        case 'MAX_TOKENS':
-          stopReason = 'max_tokens'
-          break
-        case 'SAFETY':
-        case 'RECITATION':
-          stopReason = 'stop_sequence'
-          break
-      }
-    }
-
-    return {
-      id: data.candidates?.[0]?.id || this.generateResponseId(),
-      content,
-      toolCalls,
-      stopReason,
-      usage,
-      raw: data,
-    }
-  }
-
-  private generateToolCallId(): string {
-    return `tool_${Math.random().toString(36).substring(2, 15)}`
-  }
-
-  private generateResponseId(): string {
-    return `resp_${Math.random().toString(36).substring(2, 15)}`
-  }
-}
-
-function buildTranscriptionInstruction(request: TranscribeRequest): string {
-  const parts: string[] = [
-    'Transcribe the audio to text. Return only the transcription, without commentary, timestamps, or speaker labels.',
-  ]
-  if (request.language) {
-    parts.push(`The audio is in ${request.language}. Preserve the original language in the output.`)
-  }
-  if (request.prompt) {
-    // Surface the priming hint to bias vocabulary (proper nouns, menu
-    // items, dialect markers). Kept inside the same system-style turn —
-    // Gemini doesn't have a separate "system_instruction" field that
-    // behaves differently for this use.
-    parts.push(`Context to help with vocabulary: ${request.prompt}`)
-  }
-  return parts.join(' ')
-}
-
-function extractTranscript(data: any): string {
-  const candidate = data?.candidates?.[0]
-  if (!candidate?.content?.parts) return ''
-  return candidate.content.parts
-    .map((part: any) => (typeof part?.text === 'string' ? part.text : ''))
-    .join('')
-    .trim()
-}
-
-function encodeBase64(bytes: Uint8Array): string {
-  // Node / Bun: use Buffer; falls back to atob/btoa in pure browser envs
-  // (not used in this codebase, but kept for parity with bun-types).
-  if (typeof Buffer !== 'undefined') {
-    return Buffer.from(bytes).toString('base64')
-  }
-  let binary = ''
-  for (const b of bytes) binary += String.fromCharCode(b)
-  return btoa(binary)
-}