@geenius/ai 0.1.0 → 0.3.0

package/packages/react-css/dist/index.d.cts

@@ -0,0 +1,454 @@
+import { AIGenerationType, AIChatMessage, AIRequestStatus, AILogEntry, AIModel, AIRealtimeConfig, AIRealtimeEvent, ContentGenerateOptions, ContentResult, ContentType, ContentTone, MemoryEntry, MemoryQuery, MemoryNamespace, MemoryType, MemoryImportance, SkillContext, SkillResult, SkillDefinition, SkillCategory, ChatWindowProps, AIProviderType, AILogTableProps, AIVoiceOption } from '@geenius/ai-shared';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+interface UseAIOptions {
+    /** Convex action reference for text generation (api.ai.generateText) */
+    generateTextAction?: any;
+    /** Convex action reference for image generation */
+    generateImageAction?: any;
+    /** Convex action reference for audio generation */
+    generateAudioAction?: any;
+    /** Convex action reference for transcription */
+    transcribeAudioAction?: any;
+    /** Convex action reference for video generation */
+    generateVideoAction?: any;
+}
+interface UseAIReturn {
+    generateText: (args: {
+        model: string;
+        messages: any[];
+        temperature?: number;
+        maxTokens?: number;
+        caller?: string;
+    }) => Promise<string>;
+    generateImage: (prompt: string, model?: string) => Promise<string>;
+    generateAudio: (prompt: string, voice?: string) => Promise<string>;
+    transcribeAudio: (audio: string) => Promise<string>;
+    generateVideo: (prompt: string) => Promise<string>;
+    isLoading: boolean;
+    error: string | null;
+    lastResult: string | null;
+    lastType: AIGenerationType | null;
+    clearError: () => void;
+}
+declare function useAI(options?: UseAIOptions): UseAIReturn;
+
+interface UseChatOptions {
+    conversationId?: string;
+    /** Query reference: api.ai.getConversation */
+    getConversationQuery?: any;
+    /** Query reference: api.ai.listMessages */
+    listMessagesQuery?: any;
+    /** Mutation reference: api.ai.sendMessage */
+    sendMessageMutation?: any;
+    /** Action reference: api.ai.generateText (for AI response) */
+    generateTextAction?: any;
+    /** Mutation reference: api.ai.createConversation */
+    createConversationMutation?: any;
+    model?: string;
+    systemPrompt?: string;
+    onNewConversation?: (id: string) => void;
+}
+interface UseChatReturn {
+    messages: AIChatMessage[];
+    isLoading: boolean;
+    isSending: boolean;
+    error: string | null;
+    sendMessage: (content: string) => Promise<void>;
+    conversationId: string | null;
+    clearError: () => void;
+}
+declare function useChat(options?: UseChatOptions): UseChatReturn;
+
+interface UseAILogsOptions {
+    /** Query reference: api.ai.listLogs */
+    listLogsQuery: any;
+    filters?: {
+        model?: string;
+        provider?: string;
+        status?: AIRequestStatus;
+        caller?: string;
+    };
+    limit?: number;
+}
+interface UseAILogsReturn {
+    logs: AILogEntry[];
+    isLoading: boolean;
+}
+declare function useAILogs(options: UseAILogsOptions): UseAILogsReturn;
+
+interface UseModelTestOptions {
+    /** Action reference for text: api.ai.generateText */
+    generateTextAction?: any;
+    /** Action reference for image: api.ai.generateImage */
+    generateImageAction?: any;
+    /** Action reference for audio: api.ai.generateAudio */
+    generateAudioAction?: any;
+    /** Action reference for transcription: api.ai.transcribeAudio */
+    transcribeAudioAction?: any;
+    /** Action reference for video: api.ai.generateVideo */
+    generateVideoAction?: any;
+}
+interface ModelTestResult {
+    model: string;
+    type: AIGenerationType;
+    result: string;
+    durationMs: number;
+    timestamp: number;
+    error?: string;
+}
+interface UseModelTestReturn {
+    runTest: (model: string, prompt: string, type?: AIGenerationType) => Promise<ModelTestResult>;
+    runBatchTest: (models: string[], prompt: string) => Promise<ModelTestResult[]>;
+    results: ModelTestResult[];
+    isRunning: boolean;
+    clearResults: () => void;
+}
+declare function useModelTest(options?: UseModelTestOptions): UseModelTestReturn;
+
+interface UseAIModelsOptions {
+    /** Query reference: api.ai.listModels */
+    listModelsQuery: any;
+    /** Mutation reference: api.ai.upsertModel */
+    upsertModelMutation?: any;
+}
+interface UseAIModelsReturn {
+    models: AIModel[];
+    isLoading: boolean;
+    upsertModel: (model: Partial<AIModel> & {
+        id: string;
+        provider: string;
+    }) => Promise<void>;
+}
+declare function useAIModels(options: UseAIModelsOptions): UseAIModelsReturn;
+
+interface GeneratedImage {
+    url: string;
+    prompt: string;
+    model: string;
+    timestamp: number;
+}
+interface UseImageGenerationOptions {
+    generateImageAction: any;
+    defaultModel?: string;
+}
+interface UseImageGenerationReturn {
+    generate: (prompt: string, options?: {
+        model?: string;
+        negativePrompt?: string;
+        size?: string;
+        quality?: 'standard' | 'hd';
+        style?: 'natural' | 'vivid';
+        n?: number;
+        seed?: number;
+    }) => Promise<string>;
+    images: GeneratedImage[];
+    isGenerating: boolean;
+    error: string | null;
+    clearImages: () => void;
+    clearError: () => void;
+}
+declare function useImageGeneration(options: UseImageGenerationOptions): UseImageGenerationReturn;
+
+interface UseTextToSpeechOptions {
+    generateAudioAction: any;
+    defaultVoice?: string;
+    defaultModel?: string;
+    autoPlay?: boolean;
+}
+interface UseTextToSpeechReturn {
+    speak: (text: string, options?: {
+        voice?: string;
+        model?: string;
+        speed?: number;
+        voiceSettings?: {
+            stability?: number;
+            similarityBoost?: number;
+            style?: number;
+        };
+    }) => Promise<string>;
+    stop: () => void;
+    isSpeaking: boolean;
+    isGenerating: boolean;
+    error: string | null;
+    audioUrl: string | null;
+    clearError: () => void;
+}
+declare function useTextToSpeech(options: UseTextToSpeechOptions): UseTextToSpeechReturn;
+
+interface GeneratedVideo {
+    url: string;
+    prompt: string;
+    model: string;
+    timestamp: number;
+}
+interface UseVideoGenerationOptions {
+    generateVideoAction: any;
+    defaultModel?: string;
+}
+interface UseVideoGenerationReturn {
+    generate: (prompt: string, options?: {
+        model?: string;
+        duration?: number;
+        aspectRatio?: '16:9' | '9:16' | '1:1';
+        resolution?: '720p' | '1080p' | '4k';
+        startImage?: string;
+        endImage?: string;
+    }) => Promise<string>;
+    videos: GeneratedVideo[];
+    isGenerating: boolean;
+    error: string | null;
+    clearVideos: () => void;
+    clearError: () => void;
+}
+declare function useVideoGeneration(options: UseVideoGenerationOptions): UseVideoGenerationReturn;
+
+interface TranscriptionResult {
+    text: string;
+    timestamp: number;
+    durationMs: number;
+}
+interface UseTranscriptionOptions {
+    transcribeAction: any;
+    defaultModel?: string;
+    /** Enable browser microphone recording */
+    enableMicrophone?: boolean;
+}
+interface UseTranscriptionReturn {
+    transcribe: (audioBase64: string, options?: {
+        model?: string;
+        language?: string;
+        prompt?: string;
+    }) => Promise<string>;
+    startRecording: () => Promise<void>;
+    stopRecording: () => Promise<string>;
+    isTranscribing: boolean;
+    isRecording: boolean;
+    lastResult: TranscriptionResult | null;
+    error: string | null;
+    clearError: () => void;
+}
+declare function useTranscription(options: UseTranscriptionOptions): UseTranscriptionReturn;
+
+interface UseRealtimeAudioOptions extends AIRealtimeConfig {
+    /** WebSocket URL for the realtime API session */
+    wsUrl?: string;
+    /** Gets a session token/URL from your backend */
+    getSessionAction?: any;
+    /** Called when AI responds with text */
+    onResponse?: (text: string) => void;
+    /** Called when user's speech is transcribed */
+    onTranscript?: (text: string) => void;
+    /** Called on any realtime event */
+    onEvent?: (event: AIRealtimeEvent) => void;
+}
+interface UseRealtimeAudioReturn {
+    connect: () => Promise<void>;
+    disconnect: () => void;
+    isConnected: boolean;
+    isSpeaking: boolean;
+    isListening: boolean;
+    error: string | null;
+    transcript: string;
+    response: string;
+    clearError: () => void;
+}
+declare function useRealtimeAudio(options: UseRealtimeAudioOptions): UseRealtimeAudioReturn;
+
+interface UseContentManagerOptions {
+    /** Convex action for content generation */
+    generateFn: (options: ContentGenerateOptions) => Promise<ContentResult>;
+    /** Default content type */
+    defaultType?: ContentType;
+    /** Default tone */
+    defaultTone?: ContentTone;
+    /** Default model */
+    defaultModel?: string;
+}
+interface UseContentManagerReturn {
+    /** Generate content */
+    generate: (input: string, options?: Partial<ContentGenerateOptions>) => Promise<ContentResult>;
+    /** Rewrite content */
+    rewrite: (text: string, instructions?: string) => Promise<ContentResult>;
+    /** Translate content */
+    translate: (text: string, language: string) => Promise<ContentResult>;
+    /** Summarize content */
+    summarize: (text: string) => Promise<ContentResult>;
+    /** Generate variations */
+    variations: (text: string, count?: number) => Promise<ContentResult>;
+    /** Change tone */
+    changeTone: (text: string, tone: ContentTone) => Promise<ContentResult>;
+    /** Proofread */
+    proofread: (text: string) => Promise<ContentResult>;
+    /** Current result */
+    result: ContentResult | null;
+    /** Loading state */
+    isGenerating: boolean;
+    /** Error state */
+    error: Error | null;
+    /** Clear state */
+    reset: () => void;
+}
+declare function useContentManager(options: UseContentManagerOptions): UseContentManagerReturn;
+
+interface UseMemoryOptions {
+    /** Convex mutation to store a memory */
+    storeFn: (entry: Omit<MemoryEntry, 'id' | 'accessCount' | 'lastAccessedAt' | 'createdAt' | 'updatedAt'>) => Promise<MemoryEntry>;
+    /** Convex query to search memories */
+    searchFn: (query: MemoryQuery) => Promise<MemoryEntry[]>;
+    /** Convex mutation to delete a memory */
+    deleteFn: (id: string) => Promise<void>;
+    /** Convex mutation to clear memories */
+    clearFn: (namespace: MemoryNamespace, scopeId: string) => Promise<void>;
+    /** Default namespace */
+    defaultNamespace?: MemoryNamespace;
+    /** Default scope ID (e.g., current user ID) */
+    defaultScopeId?: string;
+}
+interface UseMemoryReturn {
+    /** Store a memory */
+    store: (key: string, value: string, options?: {
+        namespace?: MemoryNamespace;
+        type?: MemoryType;
+        importance?: MemoryImportance;
+        metadata?: Record<string, unknown>;
+        scopeId?: string;
+    }) => Promise<MemoryEntry>;
+    /** Recall a specific memory by key */
+    recall: (key: string, namespace?: MemoryNamespace) => Promise<MemoryEntry | null>;
+    /** Search memories */
+    search: (query: MemoryQuery) => Promise<MemoryEntry[]>;
+    /** Delete a memory */
+    remove: (id: string) => Promise<void>;
+    /** Clear all memories in a namespace/scope */
+    clear: (namespace?: MemoryNamespace) => Promise<void>;
+    /** Currently loaded memories */
+    memories: MemoryEntry[];
+    /** Loading state */
+    isLoading: boolean;
+    /** Error state */
+    error: Error | null;
+}
+declare function useMemory(options: UseMemoryOptions): UseMemoryReturn;
+
+interface UseSkillsOptions {
+    /** Convex action to execute a skill */
+    executeFn: (context: SkillContext) => Promise<SkillResult>;
+    /** Additional custom skills to register */
+    customSkills?: SkillDefinition[];
+    /** Default model */
+    defaultModel?: string;
+    /** User ID for personalization */
+    userId?: string;
+}
+interface UseSkillsReturn {
+    /** List all available skills */
+    skills: SkillDefinition[];
+    /** List skills by category */
+    byCategory: (category: SkillCategory) => SkillDefinition[];
+    /** Search skills */
+    search: (query: string) => SkillDefinition[];
+    /** Get a skill by ID */
+    getSkill: (id: string) => SkillDefinition | undefined;
+    /** Execute a skill */
+    execute: (skillId: string, params: Record<string, unknown>, context?: Record<string, unknown>) => Promise<SkillResult>;
+    /** Last result */
+    result: SkillResult | null;
+    /** Loading state */
+    isExecuting: boolean;
+    /** Error */
+    error: Error | null;
+    /** Reset state */
+    reset: () => void;
+}
+declare function useSkills(options: UseSkillsOptions): UseSkillsReturn;
+
+interface ChatWindowComponentProps extends ChatWindowProps, UseChatOptions {
+    renderMessage?: (message: AIChatMessage) => React.ReactNode;
+    renderInput?: (props: {
+        value: string;
+        onChange: (v: string) => void;
+        onSubmit: () => void;
+        isSending: boolean;
+    }) => React.ReactNode;
+}
+declare function ChatWindow(props: ChatWindowComponentProps): react_jsx_runtime.JSX.Element;
+
+interface ModelSelectorProps {
+    models: AIModel[];
+    selectedModel?: string;
+    onSelect: (modelId: string) => void;
+    className?: string;
+    filterProvider?: AIProviderType;
+    showCost?: boolean;
+    disabled?: boolean;
+}
+declare function ModelSelector(props: ModelSelectorProps): react_jsx_runtime.JSX.Element;
+
+interface AILogTableComponentProps extends AILogTableProps {
+    logs: AILogEntry[];
+    isLoading: boolean;
+    onRowClick?: (log: AILogEntry) => void;
+}
+declare function AILogTable(props: AILogTableComponentProps): react_jsx_runtime.JSX.Element;
+
+interface ModelTestRunnerProps extends UseModelTestOptions {
+    className?: string;
+    availableModels?: string[];
+    defaultTab?: AIGenerationType;
+    renderResult?: (result: ModelTestResult) => React.ReactNode;
+}
+declare function ModelTestRunner(props: ModelTestRunnerProps): react_jsx_runtime.JSX.Element;
+
+interface GenerationCardProps {
+    type: AIGenerationType;
+    content: string;
+    model?: string;
+    durationMs?: number;
+    tokens?: number;
+    cost?: number;
+    error?: string;
+    className?: string;
+}
+declare function GenerationCard(props: GenerationCardProps): react_jsx_runtime.JSX.Element;
+
+interface ImageGeneratorComponentProps extends UseImageGenerationOptions {
+    className?: string;
+    availableModels?: string[];
+}
+declare function ImageGenerator(props: ImageGeneratorComponentProps): react_jsx_runtime.JSX.Element;
+
+interface VoiceSelectorComponentProps {
+    voices: AIVoiceOption[];
+    selectedVoice?: string;
+    onSelect: (voiceId: string) => void;
+    className?: string;
+    disabled?: boolean;
+    showProvider?: boolean;
+    showPreview?: boolean;
+    onPreview?: (voiceId: string) => void;
+}
+declare function VoiceSelector(props: VoiceSelectorComponentProps): react_jsx_runtime.JSX.Element;
+
+interface ChatPageProps extends Omit<ChatWindowComponentProps, 'conversationId'> {
+    className?: string;
+    /** Initial conversation ID */
+    conversationId?: string;
+}
+declare function ChatPage(props: ChatPageProps): react_jsx_runtime.JSX.Element;
+
+interface ModelTestPageProps extends ModelTestRunnerProps {
+    title?: string;
+}
+declare function ModelTestPage(props: ModelTestPageProps): react_jsx_runtime.JSX.Element;
+
+interface AILogsPageProps {
+    /** Query reference: api.ai.listLogs */
+    listLogsQuery: any;
+    className?: string;
+    title?: string;
+    onRowClick?: (log: AILogEntry) => void;
+}
+declare function AILogsPage(props: AILogsPageProps): react_jsx_runtime.JSX.Element;
+
+export { AILogTable, type AILogTableComponentProps, AILogsPage, type AILogsPageProps, ChatPage, type ChatPageProps, ChatWindow, type ChatWindowComponentProps, type GeneratedImage, type GeneratedVideo, GenerationCard, type GenerationCardProps, ImageGenerator, type ImageGeneratorComponentProps, ModelSelector, type ModelSelectorProps, ModelTestPage, type ModelTestPageProps, type ModelTestResult, ModelTestRunner, type ModelTestRunnerProps, type TranscriptionResult, type UseAILogsOptions, type UseAILogsReturn, type UseAIModelsOptions, type UseAIModelsReturn, type UseAIOptions, type UseAIReturn, type UseChatOptions, type UseChatReturn, type UseContentManagerOptions, type UseContentManagerReturn, type UseImageGenerationOptions, type UseImageGenerationReturn, type UseMemoryOptions, type UseMemoryReturn, type UseModelTestOptions, type UseModelTestReturn, type UseRealtimeAudioOptions, type UseRealtimeAudioReturn, type UseSkillsOptions, type UseSkillsReturn, type UseTextToSpeechOptions, type UseTextToSpeechReturn, type UseTranscriptionOptions, type UseTranscriptionReturn, type UseVideoGenerationOptions, type UseVideoGenerationReturn, VoiceSelector, type VoiceSelectorComponentProps, useAI, useAILogs, useAIModels, useChat, useContentManager, useImageGeneration, useMemory, useModelTest, useRealtimeAudio, useSkills, useTextToSpeech, useTranscription, useVideoGeneration };