@geenius/ai 0.1.0

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

@@ -0,0 +1,28 @@
+// @geenius-ai/shared — src/providers/index.ts
+
+export type { AIProviderInterface } from './base'
+export { extractPromptText } from './base'
+
+export {
+    OpenAICompatibleProvider,
+    type OpenAICompatibleConfig,
+} from './openai-compatible'
+
+export {
+    ElevenLabsProvider,
+    type ElevenLabsConfig,
+} from './elevenlabs'
+
+export {
+    ReplicateProvider,
+    type ReplicateConfig,
+    FalProvider,
+    type FalConfig,
+} from './replicate-fal'
+
+export {
+    createProvider,
+    resolveProviderForModel,
+    generateTextWithRetries,
+    clearProviderCache,
+} from './registry'

package/packages/shared/src/providers/openai-compatible.ts

@@ -0,0 +1,286 @@
+// @geenius-ai/shared — src/providers/openai-compatible.ts
+
+/**
+ * OpenAI-compatible provider — works with OpenAI, NVIDIA NIM, Groq,
+ * Together, Ollama, and any API that follows the OpenAI chat completions spec.
+ */
+
+import type {
+    AIProviderType,
+    AIGenerationResult,
+    AIEmbeddingResult,
+    AIGenerateTextOptions,
+    AIStructuredOutputOptions,
+    AIGenerateImageOptions,
+    AIEditImageOptions,
+    AIGenerateAudioOptions,
+    AITranscribeOptions,
+    AIGenerateVideoOptions,
+    AIEmbeddingOptions,
+} from '../types'
+import type { AIProviderInterface } from './base'
+import { extractPromptText } from './base'
+
+export interface OpenAICompatibleConfig {
+    type: AIProviderType
+    name: string
+    baseUrl: string
+    apiKey: string
+    defaultModel?: string
+    headers?: Record<string, string>
+}
+
+export class OpenAICompatibleProvider implements AIProviderInterface {
+    type: AIProviderType
+    name: string
+    private baseUrl: string
+    private apiKey: string
+    private defaultModel: string
+    private extraHeaders: Record<string, string>
+
+    constructor(config: OpenAICompatibleConfig) {
+        this.type = config.type
+        this.name = config.name
+        this.baseUrl = config.baseUrl.replace(/\/$/, '')
+        this.apiKey = config.apiKey
+        this.defaultModel = config.defaultModel ?? 'gpt-4o'
+        this.extraHeaders = config.headers ?? {}
+    }
+
+    async generateText(options: AIGenerateTextOptions): Promise<AIGenerationResult> {
+        const model = options.model || this.defaultModel
+        const startTime = Date.now()
+
+        const body: Record<string, unknown> = {
+            model,
+            messages: options.messages,
+            temperature: options.temperature ?? 0.7,
+            max_tokens: options.maxTokens ?? 2048,
+            top_p: options.topP ?? 0.9,
+            stream: false,
+        }
+
+        if (options.responseFormat) {
+            body.response_format = options.responseFormat
+        }
+
+        const response = await fetch(`${this.baseUrl}/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.apiKey}`,
+                ...this.extraHeaders,
+            },
+            body: JSON.stringify(body),
+        })
+
+        if (!response.ok) {
+            const errorText = await response.text()
+            throw new Error(`${this.name} API error (${response.status}): ${errorText}`)
+        }
+
+        const data = await response.json() as any
+        const durationMs = Date.now() - startTime
+
+        return {
+            content: data.choices?.[0]?.message?.content ?? '',
+            model,
+            provider: this.type,
+            type: 'text',
+            tokens: {
+                prompt: data.usage?.prompt_tokens ?? 0,
+                completion: data.usage?.completion_tokens ?? 0,
+                total: data.usage?.total_tokens ?? 0,
+            },
+            durationMs,
+            finishReason: data.choices?.[0]?.finish_reason,
+        }
+    }
+
+    async generateImage(options: AIGenerateImageOptions): Promise<string> {
+        const response = await fetch(`${this.baseUrl}/images/generations`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.apiKey}`,
+                'Accept': 'application/json',
+                ...this.extraHeaders,
+            },
+            body: JSON.stringify({
+                model: options.model ?? 'dall-e-3',
+                prompt: options.prompt.substring(0, 4000),
+                n: options.n ?? 1,
+                response_format: options.responseFormat ?? 'b64_json',
+                size: options.size ?? '1024x1024',
+            }),
+        })
+
+        if (!response.ok) {
+            const errorText = await response.text()
+            throw new Error(`${this.name} Image API error (${response.status}): ${errorText}`)
+        }
+
+        const data = await response.json() as any
+        return data.data?.[0]?.b64_json ?? data.data?.[0]?.url ?? ''
+    }
+
+    async generateAudio(options: AIGenerateAudioOptions): Promise<string> {
+        const response = await fetch(`${this.baseUrl}/audio/speech`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.apiKey}`,
+                ...this.extraHeaders,
+            },
+            body: JSON.stringify({
+                model: options.model ?? 'tts-1',
+                input: options.prompt,
+                voice: options.voice ?? 'alloy',
+                speed: options.speed ?? 1.0,
+                response_format: options.responseFormat ?? 'mp3',
+            }),
+        })
+
+        if (!response.ok) {
+            const errorText = await response.text()
+            throw new Error(`${this.name} Audio API error (${response.status}): ${errorText}`)
+        }
+
+        const arrayBuffer = await response.arrayBuffer()
+        const bytes = new Uint8Array(arrayBuffer)
+        let binary = ''
+        for (let i = 0; i < bytes.length; i++) {
+            binary += String.fromCharCode(bytes[i]!)
+        }
+        return btoa(binary)
+    }
+
+    async transcribeAudio(options: AITranscribeOptions): Promise<string> {
+        // Convert base64 to blob for multipart upload
+        const binaryStr = atob(options.audio)
+        const bytes = new Uint8Array(binaryStr.length)
+        for (let i = 0; i < binaryStr.length; i++) {
+            bytes[i] = binaryStr.charCodeAt(i)
+        }
+        const blob = new Blob([bytes], { type: 'audio/mp3' })
+
+        const formData = new FormData()
+        formData.append('file', blob, 'audio.mp3')
+        formData.append('model', options.model ?? 'whisper-1')
+        if (options.language) formData.append('language', options.language)
+
+        const response = await fetch(`${this.baseUrl}/audio/transcriptions`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.apiKey}`,
+                ...this.extraHeaders,
+            },
+            body: formData,
+        })
+
+        if (!response.ok) {
+            const errorText = await response.text()
+            throw new Error(`${this.name} Transcription API error (${response.status}): ${errorText}`)
+        }
+
+        const data = await response.json() as any
+        return data.text ?? ''
+    }
+
+    async generateVideo(_options: AIGenerateVideoOptions): Promise<string> {
+        throw new Error(`${this.name}: Video generation not supported via OpenAI-compatible API. Use ReplicateProvider or FalProvider.`)
+    }
+
+    async generateEmbeddings(options: AIEmbeddingOptions): Promise<AIEmbeddingResult> {
+        const startTime = Date.now()
+        const response = await fetch(`${this.baseUrl}/embeddings`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.apiKey}`,
+                ...this.extraHeaders,
+            },
+            body: JSON.stringify({
+                model: options.model ?? 'text-embedding-3-small',
+                input: options.input,
+                dimensions: options.dimensions,
+                encoding_format: options.encodingFormat ?? 'float',
+            }),
+        })
+
+        if (!response.ok) {
+            const errorText = await response.text()
+            throw new Error(`${this.name} Embeddings API error (${response.status}): ${errorText}`)
+        }
+
+        const data = await response.json() as any
+        return {
+            embeddings: (data.data ?? []).map((d: any) => d.embedding),
+            model: options.model ?? 'text-embedding-3-small',
+            provider: this.type,
+            tokens: data.usage?.total_tokens ?? 0,
+            durationMs: Date.now() - startTime,
+        }
+    }
+
+    async generateStructuredOutput(options: AIStructuredOutputOptions): Promise<AIGenerationResult> {
+        return this.generateText({
+            model: options.model,
+            messages: options.messages,
+            temperature: options.temperature,
+            maxTokens: options.maxTokens,
+            caller: options.caller,
+            responseFormat: {
+                type: 'json_schema',
+                json_schema: {
+                    name: options.schemaName ?? 'response',
+                    strict: true,
+                    schema: options.schema,
+                },
+            },
+        })
+    }
+
+    async editImage(options: AIEditImageOptions): Promise<string> {
+        const formData = new FormData()
+
+        // Convert base64 to blob
+        const imageBinary = atob(options.image)
+        const imageBytes = new Uint8Array(imageBinary.length)
+        for (let i = 0; i < imageBinary.length; i++) {
+            imageBytes[i] = imageBinary.charCodeAt(i)
+        }
+        formData.append('image', new Blob([imageBytes], { type: 'image/png' }), 'image.png')
+
+        if (options.maskImage) {
+            const maskBinary = atob(options.maskImage)
+            const maskBytes = new Uint8Array(maskBinary.length)
+            for (let i = 0; i < maskBinary.length; i++) {
+                maskBytes[i] = maskBinary.charCodeAt(i)
+            }
+            formData.append('mask', new Blob([maskBytes], { type: 'image/png' }), 'mask.png')
+        }
+
+        formData.append('prompt', options.prompt)
+        formData.append('model', options.model ?? 'dall-e-2')
+        formData.append('n', String(options.n ?? 1))
+        if (options.size) formData.append('size', options.size)
+
+        const response = await fetch(`${this.baseUrl}/images/edits`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.apiKey}`,
+                ...this.extraHeaders,
+            },
+            body: formData,
+        })
+
+        if (!response.ok) {
+            const errorText = await response.text()
+            throw new Error(`${this.name} Image Edit API error (${response.status}): ${errorText}`)
+        }
+
+        const data = await response.json() as any
+        return data.data?.[0]?.b64_json ?? data.data?.[0]?.url ?? ''
+    }
+}

package/packages/shared/src/providers/registry.ts

@@ -0,0 +1,113 @@
+// @geenius-ai/shared — src/providers/registry.ts
+
+/**
+ * Provider registry — creates and caches provider instances.
+ */
+
+import type { AIProviderConfig, AIProviderType, AIConfig, AIGenerationResult, AIGenerateTextOptions } from '../types'
+import type { AIProviderInterface } from './base'
+import { extractPromptText } from './base'
+import { OpenAICompatibleProvider } from './openai-compatible'
+
+const providerCache = new Map<string, AIProviderInterface>()
+
+/**
+ * Create a provider instance from config.
+ * OpenAI, NVIDIA, Groq, Together, and Ollama all use OpenAI-compatible APIs.
+ */
+export function createProvider(config: AIProviderConfig, apiKey: string): AIProviderInterface {
+    const cacheKey = `${config.type}:${config.baseUrl}`
+    const cached = providerCache.get(cacheKey)
+    if (cached) return cached
+
+    const provider = new OpenAICompatibleProvider({
+        type: config.type,
+        name: config.name,
+        baseUrl: config.baseUrl,
+        apiKey,
+        defaultModel: config.defaultModel,
+        headers: config.headers,
+    })
+
+    providerCache.set(cacheKey, provider)
+    return provider
+}
+
+/**
+ * Resolve a provider for a given model from the AI config.
+ * Looks up the model's provider type, finds the config, and creates the provider.
+ */
+export function resolveProviderForModel(
+    aiConfig: AIConfig,
+    modelId: string,
+    getApiKey: (envVar: string) => string | undefined,
+): AIProviderInterface {
+    const model = aiConfig.models.find(m => m.id === modelId)
+    const providerType = model?.provider ?? aiConfig.defaultProvider
+    const providerConfig = aiConfig.providers.find(p => p.type === providerType)
+
+    if (!providerConfig) {
+        throw new Error(`No provider config found for type "${providerType}"`)
+    }
+
+    const apiKey = getApiKey(providerConfig.apiKeyEnvVar)
+    if (!apiKey) {
+        throw new Error(`API key not found for ${providerConfig.name} (env: ${providerConfig.apiKeyEnvVar})`)
+    }
+
+    return createProvider(providerConfig, apiKey)
+}
+
+/**
+ * Generate text with automatic retries and logging support.
+ * This is the main entry point used by Convex actions.
+ */
+export async function generateTextWithRetries(
+    provider: AIProviderInterface,
+    options: AIGenerateTextOptions,
+    retryConfig: AIConfig['retries'],
+): Promise<AIGenerationResult> {
+    let lastError: Error | null = null
+    const { maxAttempts, retryableStatusCodes, backoffMultiplierMs } = retryConfig
+
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            const result = await provider.generateText(options)
+
+            if (!result.content) {
+                throw new Error(`Empty response from ${provider.name} (finish: ${result.finishReason})`)
+            }
+
+            if (attempt > 1) {
+                console.log(`[geenius-ai] Succeeded on attempt ${attempt}/${maxAttempts}`)
+            }
+
+            return result
+        } catch (err) {
+            lastError = err instanceof Error ? err : new Error('Unknown error')
+
+            // Check if the error contains a retryable status code
+            const isRetryable = retryableStatusCodes.some(code =>
+                lastError!.message.includes(`(${code})`)
+            )
+
+            if (isRetryable && attempt < maxAttempts) {
+                const delay = Math.pow(2, attempt - 1) * backoffMultiplierMs
+                console.log(`[geenius-ai] Attempt ${attempt}/${maxAttempts} failed. Retrying in ${delay}ms...`)
+                await new Promise(resolve => setTimeout(resolve, delay))
+                continue
+            }
+
+            throw lastError
+        }
+    }
+
+    throw lastError || new Error('All retry attempts exhausted')
+}
+
+/**
+ * Clear the provider cache (useful for testing or config changes).
+ */
+export function clearProviderCache() {
+    providerCache.clear()
+}

package/packages/shared/src/providers/replicate-fal.ts

@@ -0,0 +1,230 @@
+// @geenius-ai/shared — src/providers/replicate-fal.ts
+
+/**
+ * Replicate / Fal.ai provider — for video generation, music,
+ * and specialized models (Runway, Kling, Suno, etc.)
+ *
+ * Both use a prediction/submit-and-poll pattern.
+ */
+
+import type {
+    AIProviderType,
+    AIGenerationResult,
+    AIGenerateTextOptions,
+    AIGenerateVideoOptions,
+    AIGenerateImageOptions,
+    AIGenerateMusicOptions,
+} from '../types'
+import type { AIProviderInterface } from './base'
+
+// ============================================================================
+// Replicate
+// ============================================================================
+
+export interface ReplicateConfig {
+    apiKey: string
+    baseUrl?: string
+    /** Max poll time in ms before timeout */
+    maxWaitMs?: number
+}
+
+export class ReplicateProvider implements AIProviderInterface {
+    type: AIProviderType = 'replicate'
+    name = 'Replicate'
+    private apiKey: string
+    private baseUrl: string
+    private maxWaitMs: number
+
+    constructor(config: ReplicateConfig) {
+        this.apiKey = config.apiKey
+        this.baseUrl = (config.baseUrl ?? 'https://api.replicate.com').replace(/\/$/, '')
+        this.maxWaitMs = config.maxWaitMs ?? 300_000  // 5 min default
+    }
+
+    async generateText(_options: AIGenerateTextOptions): Promise<AIGenerationResult> {
+        throw new Error('Use Replicate for image/video/music generation, not text.')
+    }
+
+    async generateImage(options: AIGenerateImageOptions): Promise<string> {
+        const model = options.model ?? 'stability-ai/sdxl'
+        return await this.runPrediction(model, {
+            prompt: options.prompt,
+            negative_prompt: options.negativePrompt,
+            width: parseInt(options.size?.split('x')[0] ?? '1024'),
+            height: parseInt(options.size?.split('x')[1] ?? '1024'),
+            num_outputs: options.n ?? 1,
+            seed: options.seed,
+        })
+    }
+
+    async generateVideo(options: AIGenerateVideoOptions): Promise<string> {
+        const model = options.model ?? 'minimax/video-01'
+        const input: Record<string, unknown> = {
+            prompt: options.prompt,
+        }
+        if (options.startImage) input.first_frame_image = options.startImage
+        if (options.endImage) input.last_frame_image = options.endImage
+
+        return await this.runPrediction(model, input)
+    }
+
+    async generateMusic(options: AIGenerateMusicOptions): Promise<string> {
+        const model = options.model ?? 'meta/musicgen'
+        return await this.runPrediction(model, {
+            prompt: options.prompt,
+            duration: options.duration ?? 10,
+        })
+    }
+
+    /** Core submit-and-poll logic */
+    private async runPrediction(model: string, input: Record<string, unknown>): Promise<string> {
+        // Submit prediction
+        const createResponse = await fetch(`${this.baseUrl}/v1/predictions`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.apiKey}`,
+                'Prefer': 'wait',
+            },
+            body: JSON.stringify({
+                model,
+                input,
+            }),
+        })
+
+        if (!createResponse.ok) {
+            const errorText = await createResponse.text()
+            throw new Error(`Replicate error (${createResponse.status}): ${errorText}`)
+        }
+
+        let prediction = await createResponse.json() as any
+
+        // Poll for completion if not already done
+        const startTime = Date.now()
+        while (prediction.status !== 'succeeded' && prediction.status !== 'failed') {
+            if (Date.now() - startTime > this.maxWaitMs) {
+                throw new Error(`Replicate prediction timed out after ${this.maxWaitMs}ms`)
+            }
+            await new Promise(r => setTimeout(r, 2000))
+
+            const pollResponse = await fetch(prediction.urls?.get ?? `${this.baseUrl}/v1/predictions/${prediction.id}`, {
+                headers: { 'Authorization': `Bearer ${this.apiKey}` },
+            })
+            prediction = await pollResponse.json()
+        }
+
+        if (prediction.status === 'failed') {
+            throw new Error(`Replicate prediction failed: ${prediction.error ?? 'Unknown error'}`)
+        }
+
+        // Output is typically a URL or array of URLs
+        const output = prediction.output
+        if (Array.isArray(output)) return output[0]
+        return typeof output === 'string' ? output : JSON.stringify(output)
+    }
+}
+
+// ============================================================================
+// Fal.ai
+// ============================================================================
+
+export interface FalConfig {
+    apiKey: string
+    baseUrl?: string
+    maxWaitMs?: number
+}
+
+export class FalProvider implements AIProviderInterface {
+    type: AIProviderType = 'fal'
+    name = 'Fal.ai'
+    private apiKey: string
+    private baseUrl: string
+    private maxWaitMs: number
+
+    constructor(config: FalConfig) {
+        this.apiKey = config.apiKey
+        this.baseUrl = (config.baseUrl ?? 'https://queue.fal.run').replace(/\/$/, '')
+        this.maxWaitMs = config.maxWaitMs ?? 300_000
+    }
+
+    async generateText(_options: AIGenerateTextOptions): Promise<AIGenerationResult> {
+        throw new Error('Use Fal.ai for image/video generation, not text.')
+    }
+
+    async generateImage(options: AIGenerateImageOptions): Promise<string> {
+        const model = options.model ?? 'fal-ai/flux/dev'
+        return await this.runModel(model, {
+            prompt: options.prompt,
+            negative_prompt: options.negativePrompt,
+            image_size: options.size ?? '1024x1024',
+            num_images: options.n ?? 1,
+            seed: options.seed,
+        })
+    }
+
+    async generateVideo(options: AIGenerateVideoOptions): Promise<string> {
+        const model = options.model ?? 'fal-ai/kling-video/v2/master'
+        return await this.runModel(model, {
+            prompt: options.prompt,
+            duration: options.duration ? `${options.duration}` : '5',
+            aspect_ratio: options.aspectRatio ?? '16:9',
+            image_url: options.startImage,
+        })
+    }
+
+    /** Core queue-based submit-and-poll */
+    private async runModel(model: string, input: Record<string, unknown>): Promise<string> {
+        // Submit to queue
+        const submitResponse = await fetch(`${this.baseUrl}/${model}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Key ${this.apiKey}`,
+            },
+            body: JSON.stringify(input),
+        })
+
+        if (!submitResponse.ok) {
+            const errorText = await submitResponse.text()
+            throw new Error(`Fal.ai error (${submitResponse.status}): ${errorText}`)
+        }
+
+        let result = await submitResponse.json() as any
+
+        // If queued, poll for result
+        if (result.request_id) {
+            const statusUrl = `https://queue.fal.run/${model}/requests/${result.request_id}/status`
+            const resultUrl = `https://queue.fal.run/${model}/requests/${result.request_id}`
+            const startTime = Date.now()
+
+            while (true) {
+                if (Date.now() - startTime > this.maxWaitMs) {
+                    throw new Error(`Fal.ai timed out after ${this.maxWaitMs}ms`)
+                }
+                await new Promise(r => setTimeout(r, 2000))
+
+                const statusResponse = await fetch(statusUrl, {
+                    headers: { 'Authorization': `Key ${this.apiKey}` },
+                })
+                const status = await statusResponse.json() as any
+
+                if (status.status === 'COMPLETED') {
+                    const resultResponse = await fetch(resultUrl, {
+                        headers: { 'Authorization': `Key ${this.apiKey}` },
+                    })
+                    result = await resultResponse.json()
+                    break
+                }
+                if (status.status === 'FAILED') {
+                    throw new Error(`Fal.ai failed: ${status.error ?? 'Unknown error'}`)
+                }
+            }
+        }
+
+        // Extract URL from response
+        if (result.images) return result.images[0]?.url ?? ''
+        if (result.video) return result.video?.url ?? ''
+        if (result.audio) return result.audio?.url ?? ''
+        return typeof result.output === 'string' ? result.output : JSON.stringify(result)
+    }
+}