@geenius/adapters 0.1.0

package/packages/shared/src/ai/anthropic.ts

@@ -0,0 +1,123 @@
+// @geenius/adapters — Anthropic implementation (MVP tier)
+// Wraps the Anthropic API to conform to AiAdapter interface.
+// Requires: @anthropic-ai/sdk
+
+import type { ChatMessage, ChatResponse, AiOptions } from '../types'
+import type { AiAdapter } from './interface'
+
+interface AnthropicStreamEvent {
+  type: string
+  delta?: { type: string; text?: string }
+}
+
+interface AnthropicClient {
+  messages: {
+    create(params: {
+      model: string
+      max_tokens: number
+      system?: string
+      messages: Array<{ role: 'user' | 'assistant'; content: string }>
+      temperature?: number
+      stream?: false
+    }): Promise<{
+      content: Array<{ type: string; text?: string }>
+      stop_reason: string | null
+      usage: { input_tokens: number; output_tokens: number }
+    }>
+    create(params: {
+      model: string
+      max_tokens: number
+      system?: string
+      messages: Array<{ role: 'user' | 'assistant'; content: string }>
+      temperature?: number
+      stream: true
+    }): Promise<AsyncIterable<AnthropicStreamEvent>>
+  }
+}
+
+export interface AnthropicAdapterOptions {
+  /** Pre-configured Anthropic client instance */
+  client: AnthropicClient
+  /** Default model (default: claude-sonnet-4-20250514) */
+  defaultModel?: string
+}
+
+export function createAnthropicAdapter(options: AnthropicAdapterOptions): AiAdapter {
+  const {
+    client,
+    defaultModel = 'claude-sonnet-4-20250514',
+  } = options
+
+  return {
+    async chat(messages: ChatMessage[], opts?: AiOptions): Promise<ChatResponse> {
+      // Anthropic handles system messages separately
+      const systemMsg = messages.find((m) => m.role === 'system')
+      const nonSystemMsgs = messages
+        .filter((m) => m.role !== 'system')
+        .map((m) => ({
+          role: m.role as 'user' | 'assistant',
+          content: m.content,
+        }))
+
+      const response = await client.messages.create({
+        model: opts?.model || defaultModel,
+        max_tokens: opts?.maxTokens || 4096,
+        system: systemMsg?.content,
+        messages: nonSystemMsgs,
+        temperature: opts?.temperature,
+      })
+
+      const textBlock = response.content.find((c) => c.type === 'text')
+      return {
+        content: textBlock?.text || '',
+        finishReason: (response.stop_reason === 'end_turn' ? 'stop'
+          : response.stop_reason === 'max_tokens' ? 'length'
+          : 'error') as ChatResponse['finishReason'],
+        usage: {
+          promptTokens: response.usage.input_tokens,
+          completionTokens: response.usage.output_tokens,
+          totalTokens: response.usage.input_tokens + response.usage.output_tokens,
+        },
+      }
+    },
+
+    async complete(prompt: string, opts?: AiOptions): Promise<string> {
+      const response = await this.chat(
+        [{ role: 'user', content: prompt }],
+        opts,
+      )
+      return response.content
+    },
+
+    async embed(_text: string | string[]): Promise<number[][]> {
+      // Anthropic doesn't offer an embeddings API
+      // Users should use OpenAI or a dedicated embedding service
+      throw new Error(
+        'Anthropic does not provide an embeddings API. ' +
+        'Use createOpenAiAdapter for embeddings, or a dedicated embedding service.'
+      )
+    },
+
+    async *stream(messages: ChatMessage[], opts?: AiOptions): AsyncIterable<string> {
+      const systemMsg = messages.find((m) => m.role === 'system')
+      const nonSystemMsgs = messages
+        .filter((m) => m.role !== 'system')
+        .map((m) => ({ role: m.role as 'user' | 'assistant', content: m.content }))
+
+      const iterable = await client.messages.create({
+        model: opts?.model || defaultModel,
+        max_tokens: opts?.maxTokens || 4096,
+        system: systemMsg?.content,
+        messages: nonSystemMsgs,
+        temperature: opts?.temperature,
+        stream: true,
+      })
+
+      for await (const event of iterable) {
+        if (event.type === 'content_block_delta' && event.delta?.type === 'text_delta' && event.delta.text) {
+          yield event.delta.text
+        }
+      }
+    },
+  }
+}

package/packages/shared/src/ai/cloudflare-gateway.ts

@@ -0,0 +1,130 @@
+// @geenius/adapters — Cloudflare AI Gateway adapter
+// Proxies requests through Cloudflare AI Gateway for caching, rate limiting,
+// analytics, and fallback routing — while using any underlying AI model.
+// Uses the OpenAI-compatible gateway endpoint.
+
+import type { ChatMessage, ChatResponse, AiOptions } from '../types'
+import type { AiAdapter } from './interface'
+
+export interface CloudflareAiGatewayOptions {
+  /** Cloudflare account ID */
+  accountId: string
+  /** AI Gateway name/ID */
+  gatewayId: string
+  /** The upstream provider to route through (e.g. 'openai', 'anthropic', 'google-ai-studio', 'workers-ai') */
+  provider: 'openai' | 'anthropic' | 'google-ai-studio' | 'workers-ai' | 'azure-openai' | 'groq' | 'cohere' | string
+  /** API key for the upstream provider */
+  apiKey: string
+  /** Default model */
+  defaultModel?: string
+  /** Embedding model */
+  embeddingModel?: string
+  /** Custom gateway base URL (default: Cloudflare's) */
+  baseUrl?: string
+  /** Enable gateway caching (default: false) */
+  cacheTtl?: number
+  /** Retry on failure (default: false) */
+  retries?: number
+}
+
+export function createCloudflareAiGatewayAdapter(options: CloudflareAiGatewayOptions): AiAdapter {
+  const {
+    accountId,
+    gatewayId,
+    provider,
+    apiKey,
+    defaultModel = 'gpt-4o-mini',
+    embeddingModel = 'text-embedding-3-small',
+    baseUrl,
+    cacheTtl,
+    retries,
+  } = options
+
+  const gatewayUrl = baseUrl || `https://gateway.ai.cloudflare.com/v1/${accountId}/${gatewayId}/${provider}`
+
+  function getHeaders(): Record<string, string> {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    }
+
+    // Set auth header based on provider
+    if (provider === 'anthropic') {
+      headers['x-api-key'] = apiKey
+      headers['anthropic-version'] = '2023-06-01'
+    } else {
+      headers['Authorization'] = `Bearer ${apiKey}`
+    }
+
+    // Cloudflare gateway-specific headers
+    if (cacheTtl) headers['cf-aig-cache-ttl'] = String(cacheTtl)
+    if (retries) headers['cf-aig-skip-cache'] = 'false'
+
+    return headers
+  }
+
+  return {
+    async chat(messages: ChatMessage[], opts?: AiOptions): Promise<ChatResponse> {
+      const model = opts?.model || defaultModel
+
+      // Use OpenAI-compatible format (supported by gateway for most providers)
+      const body = {
+        model,
+        messages: messages.map((m) => ({ role: m.role, content: m.content })),
+        temperature: opts?.temperature,
+        max_tokens: opts?.maxTokens,
+      }
+
+      const response = await fetch(`${gatewayUrl}/chat/completions`, {
+        method: 'POST',
+        headers: getHeaders(),
+        body: JSON.stringify(body),
+      })
+
+      if (!response.ok) {
+        const error = await response.text()
+        throw new Error(`Cloudflare AI Gateway error: ${response.status} — ${error}`)
+      }
+
+      const data = await response.json()
+      const choice = data.choices?.[0]
+
+      return {
+        content: choice?.message?.content || '',
+        finishReason: (choice?.finish_reason === 'stop' ? 'stop'
+          : choice?.finish_reason === 'length' ? 'length'
+          : 'error') as ChatResponse['finishReason'],
+        usage: data.usage ? {
+          promptTokens: data.usage.prompt_tokens || 0,
+          completionTokens: data.usage.completion_tokens || 0,
+          totalTokens: data.usage.total_tokens || 0,
+        } : undefined,
+      }
+    },
+
+    async complete(prompt: string, opts?: AiOptions): Promise<string> {
+      const response = await this.chat(
+        [{ role: 'user', content: prompt }],
+        opts,
+      )
+      return response.content
+    },
+
+    async embed(text: string | string[]): Promise<number[][]> {
+      const response = await fetch(`${gatewayUrl}/embeddings`, {
+        method: 'POST',
+        headers: getHeaders(),
+        body: JSON.stringify({
+          model: embeddingModel,
+          input: text,
+        }),
+      })
+
+      if (!response.ok) {
+        throw new Error(`Cloudflare AI Gateway embedding error: ${response.status}`)
+      }
+
+      const data = await response.json()
+      return data.data?.map((d: any) => d.embedding) || []
+    },
+  }
+}

package/packages/shared/src/ai/gemini.ts

@@ -0,0 +1,181 @@
+// @geenius/adapters — Google Gemini native AI adapter
+// Uses the Gemini REST API directly (no SDK dependency required).
+// Supports chat, completion, and embeddings.
+
+import type { ChatMessage, ChatResponse, AiOptions } from '../types'
+import type { AiAdapter } from './interface'
+
+export interface GeminiAdapterOptions {
+  /** Google AI API key */
+  apiKey: string
+  /** Default model (default: gemini-2.0-flash) */
+  defaultModel?: string
+  /** Embedding model (default: text-embedding-004) */
+  embeddingModel?: string
+  /** Base URL (default: https://generativelanguage.googleapis.com/v1beta) */
+  baseUrl?: string
+}
+
+export function createGeminiAdapter(options: GeminiAdapterOptions): AiAdapter {
+  const {
+    apiKey,
+    defaultModel = 'gemini-2.0-flash',
+    embeddingModel = 'text-embedding-004',
+    baseUrl = 'https://generativelanguage.googleapis.com/v1beta',
+  } = options
+
+  function mapRole(role: string): string {
+    if (role === 'assistant') return 'model'
+    if (role === 'system') return 'user' // Gemini handles system via systemInstruction
+    return 'user'
+  }
+
+  return {
+    async chat(messages: ChatMessage[], opts?: AiOptions): Promise<ChatResponse> {
+      const model = opts?.model || defaultModel
+
+      // Extract system message for Gemini's systemInstruction
+      const systemMsg = messages.find((m) => m.role === 'system')
+      const nonSystemMsgs = messages.filter((m) => m.role !== 'system')
+
+      const body: any = {
+        contents: nonSystemMsgs.map((m) => ({
+          role: mapRole(m.role),
+          parts: [{ text: m.content }],
+        })),
+        generationConfig: {
+          temperature: opts?.temperature,
+          maxOutputTokens: opts?.maxTokens,
+        },
+      }
+
+      if (systemMsg) {
+        body.systemInstruction = { parts: [{ text: systemMsg.content }] }
+      }
+
+      const response = await fetch(
+        `${baseUrl}/models/${model}:generateContent?key=${apiKey}`,
+        {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(body),
+        },
+      )
+
+      if (!response.ok) {
+        const error = await response.text()
+        throw new Error(`Gemini API error: ${response.status} — ${error}`)
+      }
+
+      const data = await response.json()
+      const candidate = data.candidates?.[0]
+      const text = candidate?.content?.parts?.[0]?.text || ''
+      const finishReason = candidate?.finishReason === 'STOP' ? 'stop'
+        : candidate?.finishReason === 'MAX_TOKENS' ? 'length'
+        : 'error'
+
+      return {
+        content: text,
+        finishReason: finishReason as ChatResponse['finishReason'],
+        usage: data.usageMetadata ? {
+          promptTokens: data.usageMetadata.promptTokenCount || 0,
+          completionTokens: data.usageMetadata.candidatesTokenCount || 0,
+          totalTokens: data.usageMetadata.totalTokenCount || 0,
+        } : undefined,
+      }
+    },
+
+    async complete(prompt: string, opts?: AiOptions): Promise<string> {
+      const response = await this.chat(
+        [{ role: 'user', content: prompt }],
+        opts,
+      )
+      return response.content
+    },
+
+    async embed(text: string | string[]): Promise<number[][]> {
+      const inputs = Array.isArray(text) ? text : [text]
+      const results: number[][] = []
+
+      for (const input of inputs) {
+        const response = await fetch(
+          `${baseUrl}/models/${embeddingModel}:embedContent?key=${apiKey}`,
+          {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              model: `models/${embeddingModel}`,
+              content: { parts: [{ text: input }] },
+            }),
+          },
+        )
+
+        if (!response.ok) {
+          throw new Error(`Gemini embedding error: ${response.status}`)
+        }
+
+        const data = await response.json()
+        results.push(data.embedding?.values || [])
+      }
+
+      return results
+    },
+
+    async *stream(messages: ChatMessage[], opts?: AiOptions): AsyncIterable<string> {
+      const model = opts?.model || defaultModel
+      const systemMsg = messages.find((m) => m.role === 'system')
+      const nonSystemMsgs = messages.filter((m) => m.role !== 'system')
+
+      const body: any = {
+        contents: nonSystemMsgs.map((m) => ({
+          role: mapRole(m.role),
+          parts: [{ text: m.content }],
+        })),
+        generationConfig: {
+          temperature: opts?.temperature,
+          maxOutputTokens: opts?.maxTokens,
+        },
+      }
+
+      if (systemMsg) {
+        body.systemInstruction = { parts: [{ text: systemMsg.content }] }
+      }
+
+      const response = await fetch(
+        `${baseUrl}/models/${model}:streamGenerateContent?key=${apiKey}&alt=sse`,
+        {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify(body),
+        },
+      )
+
+      if (!response.ok || !response.body) {
+        const error = await response.text()
+        throw new Error(`Gemini stream error: ${response.status} — ${error}`)
+      }
+
+      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) {
+          if (!line.startsWith('data: ')) continue
+          const json = line.slice(6).trim()
+          if (!json || json === '[DONE]') continue
+          try {
+            const chunk = JSON.parse(json)
+            const text = chunk.candidates?.[0]?.content?.parts?.[0]?.text
+            if (text) yield text
+          } catch { /* skip malformed chunks */ }
+        }
+      }
+    },
+  }
+}

package/packages/shared/src/ai/index.ts

@@ -0,0 +1,14 @@
+export type { AiAdapter } from './interface'
+export { createLocalStorageAiAdapter } from './localStorage'
+export { createOpenAiAdapter } from './openai'
+export type { OpenAiAdapterOptions } from './openai'
+export { createAnthropicAdapter } from './anthropic'
+export type { AnthropicAdapterOptions } from './anthropic'
+export { createGeminiAdapter } from './gemini'
+export type { GeminiAdapterOptions } from './gemini'
+export { createOllamaAdapter } from './ollama'
+export type { OllamaAdapterOptions } from './ollama'
+export { createCloudflareAiGatewayAdapter } from './cloudflare-gateway'
+export type { CloudflareAiGatewayOptions } from './cloudflare-gateway'
+export { createVercelAiAdapter } from './vercel-ai'
+export type { VercelAiAdapterOptions } from './vercel-ai'

package/packages/shared/src/ai/interface.ts

@@ -0,0 +1,11 @@
+// @geenius/adapters — AI adapter interface
+
+import type { ChatMessage, ChatResponse, AiOptions } from '../types'
+
+export interface AiAdapter {
+  chat(messages: ChatMessage[], options?: AiOptions): Promise<ChatResponse>
+  complete(prompt: string, options?: AiOptions): Promise<string>
+  embed(text: string | string[]): Promise<number[][]>
+  /** Stream chat tokens as an async iterable of text deltas. Optional — falls back to chat() if not implemented. */
+  stream?(messages: ChatMessage[], options?: AiOptions): AsyncIterable<string>
+}

package/packages/shared/src/ai/localStorage.ts

@@ -0,0 +1,78 @@
+// @geenius/adapters — localStorage AI implementation (canned responses)
+
+import type { ChatMessage, ChatResponse, AiOptions } from '../types'
+import type { AiAdapter } from './interface'
+
+const HISTORY_KEY = 'geenius_ai_history'
+
+const CANNED_RESPONSES = [
+  "That's an interesting question! In the Pronto tier, AI responses are simulated. Upgrade to MVP for real AI.",
+  "I'm a mock AI assistant. I can demonstrate the chat interface, but for real responses you'll need the MVP tier.",
+  "Great question! This is a localStorage-based AI mock. The real AI adapter connects to OpenAI/Anthropic APIs.",
+  "I appreciate your input! This demo shows how the AI interface works. Upgrade for actual AI capabilities.",
+  "Interesting! While I can't provide real AI analysis in Pronto, this shows the adapter pattern in action.",
+]
+
+function getCannedResponse(messages: ChatMessage[]): string {
+  const lastMsg = messages[messages.length - 1]?.content || ''
+  // Deterministic but varied: hash the message to pick a response
+  let hash = 0
+  for (let i = 0; i < lastMsg.length; i++) { hash = ((hash << 5) - hash) + lastMsg.charCodeAt(i); hash |= 0 }
+  return CANNED_RESPONSES[Math.abs(hash) % CANNED_RESPONSES.length]
+}
+
+function saveToHistory(messages: ChatMessage[], response: string) {
+  try {
+    const history = JSON.parse(localStorage.getItem(HISTORY_KEY) || '[]')
+    history.push({ timestamp: new Date().toISOString(), messages, response })
+    // Keep last 50 conversations
+    if (history.length > 50) history.splice(0, history.length - 50)
+    localStorage.setItem(HISTORY_KEY, JSON.stringify(history))
+  } catch { /* ignore storage errors */ }
+}
+
+export function createLocalStorageAiAdapter(): AiAdapter {
+  return {
+    async chat(messages: ChatMessage[], _options?: AiOptions): Promise<ChatResponse> {
+      // Simulate network delay
+      await new Promise(r => setTimeout(r, 300 + Math.random() * 700))
+      const content = getCannedResponse(messages)
+      saveToHistory(messages, content)
+      return {
+        content,
+        finishReason: 'stop',
+        usage: { promptTokens: 10, completionTokens: 20, totalTokens: 30 },
+      }
+    },
+
+    async complete(prompt: string, options?: AiOptions): Promise<string> {
+      const response = await this.chat([{ role: 'user', content: prompt }], options)
+      return response.content
+    },
+
+    async embed(text: string | string[]): Promise<number[][]> {
+      const inputs = Array.isArray(text) ? text : [text]
+      // Return mock 8-dimensional embeddings (deterministic from text)
+      return inputs.map(t => {
+        const vec: number[] = []
+        for (let i = 0; i < 8; i++) {
+          let h = i * 31
+          for (let j = 0; j < t.length; j++) { h = ((h << 5) - h) + t.charCodeAt(j); h |= 0 }
+          vec.push(Math.sin(h) * 0.5 + 0.5)
+        }
+        return vec
+      })
+    },
+
+    async *stream(messages: ChatMessage[], _options?: AiOptions): AsyncIterable<string> {
+      // Simulate streaming by yielding the canned response word-by-word
+      const content = getCannedResponse(messages)
+      saveToHistory(messages, content)
+      const words = content.split(' ')
+      for (const word of words) {
+        await new Promise(r => setTimeout(r, 40 + Math.random() * 60))
+        yield word + ' '
+      }
+    },
+  }
+}

package/packages/shared/src/ai/ollama.ts

@@ -0,0 +1,143 @@
+// @geenius/adapters — Ollama AI adapter (local LLMs)
+// Uses Ollama's REST API (no SDK dependency required).
+// Supports chat, completion, and embeddings — all running locally.
+
+import type { ChatMessage, ChatResponse, AiOptions } from '../types'
+import type { AiAdapter } from './interface'
+
+export interface OllamaAdapterOptions {
+  /** Ollama server URL (default: http://localhost:11434) */
+  host?: string
+  /** Default model (default: llama3.2) */
+  defaultModel?: string
+  /** Embedding model (default: nomic-embed-text) */
+  embeddingModel?: string
+}
+
+export function createOllamaAdapter(options: OllamaAdapterOptions = {}): AiAdapter {
+  const {
+    host = 'http://localhost:11434',
+    defaultModel = 'llama3.2',
+    embeddingModel = 'nomic-embed-text',
+  } = options
+
+  return {
+    async chat(messages: ChatMessage[], opts?: AiOptions): Promise<ChatResponse> {
+      const response = await fetch(`${host}/api/chat`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          model: opts?.model || defaultModel,
+          messages: messages.map((m) => ({ role: m.role, content: m.content })),
+          stream: false,
+          options: {
+            temperature: opts?.temperature,
+            num_predict: opts?.maxTokens,
+          },
+        }),
+      })
+
+      if (!response.ok) {
+        throw new Error(`Ollama API error: ${response.status} — ${response.statusText}`)
+      }
+
+      const data = await response.json()
+
+      return {
+        content: data.message?.content || '',
+        finishReason: data.done ? 'stop' : 'length',
+        usage: {
+          promptTokens: data.prompt_eval_count || 0,
+          completionTokens: data.eval_count || 0,
+          totalTokens: (data.prompt_eval_count || 0) + (data.eval_count || 0),
+        },
+      }
+    },
+
+    async complete(prompt: string, opts?: AiOptions): Promise<string> {
+      // Use the generate endpoint for simple completions
+      const response = await fetch(`${host}/api/generate`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          model: opts?.model || defaultModel,
+          prompt,
+          stream: false,
+          options: {
+            temperature: opts?.temperature,
+            num_predict: opts?.maxTokens,
+          },
+        }),
+      })
+
+      if (!response.ok) {
+        throw new Error(`Ollama API error: ${response.status}`)
+      }
+
+      const data = await response.json()
+      return data.response || ''
+    },
+
+    async embed(text: string | string[]): Promise<number[][]> {
+      const inputs = Array.isArray(text) ? text : [text]
+      const results: number[][] = []
+
+      for (const input of inputs) {
+        const response = await fetch(`${host}/api/embed`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            model: embeddingModel,
+            input,
+          }),
+        })
+
+        if (!response.ok) {
+          throw new Error(`Ollama embedding error: ${response.status}`)
+        }
+
+        const data = await response.json()
+        results.push(data.embeddings?.[0] || [])
+      }
+
+      return results
+    },
+
+    async *stream(messages: ChatMessage[], opts?: AiOptions): AsyncIterable<string> {
+      const response = await fetch(`${host}/api/chat`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          model: opts?.model || defaultModel,
+          messages: messages.map((m) => ({ role: m.role, content: m.content })),
+          stream: true,
+          options: {
+            temperature: opts?.temperature,
+            num_predict: opts?.maxTokens,
+          },
+        }),
+      })
+
+      if (!response.ok || !response.body) {
+        throw new Error(`Ollama stream error: ${response.status} — ${response.statusText}`)
+      }
+
+      const reader = response.body.getReader()
+      const decoder = new TextDecoder()
+
+      while (true) {
+        const { done, value } = await reader.read()
+        if (done) break
+        const lines = decoder.decode(value, { stream: true }).split('\n').filter(Boolean)
+        for (const line of lines) {
+          try {
+            const chunk = JSON.parse(line)
+            const delta = chunk.message?.content
+            if (delta) yield delta
+            if (chunk.done) return
+          } catch { /* skip malformed lines */ }
+        }
+      }
+    },
+  }
+}