@geenius/ai 0.1.0 → 0.3.1

package/packages/react-css/dist/index.js

@@ -0,0 +1,1495 @@
+// src/hooks/useAI.ts
+import { useState, useCallback } from "react";
+import { useAction } from "convex/react";
+function useAI(options = {}) {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [lastResult, setLastResult] = useState(null);
+  const [lastType, setLastType] = useState(null);
+  const textAction = options.generateTextAction ? useAction(options.generateTextAction) : null;
+  const imageAction = options.generateImageAction ? useAction(options.generateImageAction) : null;
+  const audioAction = options.generateAudioAction ? useAction(options.generateAudioAction) : null;
+  const transcribeAction = options.transcribeAudioAction ? useAction(options.transcribeAudioAction) : null;
+  const videoAction = options.generateVideoAction ? useAction(options.generateVideoAction) : null;
+  const generateText = useCallback(async (args) => {
+    if (!textAction) throw new Error("generateTextAction not provided");
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await textAction(args);
+      setLastResult(result);
+      setLastType("text");
+      return result;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Text generation failed";
+      setError(msg);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [textAction]);
+  const generateImage = useCallback(async (prompt, model) => {
+    if (!imageAction) throw new Error("generateImageAction not provided");
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await imageAction({ prompt, model });
+      setLastResult(result);
+      setLastType("image");
+      return result;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Image generation failed";
+      setError(msg);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [imageAction]);
+  const generateAudio = useCallback(async (prompt, voice) => {
+    if (!audioAction) throw new Error("generateAudioAction not provided");
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await audioAction({ prompt, voice });
+      setLastResult(result);
+      setLastType("audio");
+      return result;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Audio generation failed";
+      setError(msg);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [audioAction]);
+  const transcribeAudio = useCallback(async (audio) => {
+    if (!transcribeAction) throw new Error("transcribeAudioAction not provided");
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await transcribeAction({ audio });
+      setLastResult(result);
+      setLastType("transcription");
+      return result;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Transcription failed";
+      setError(msg);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [transcribeAction]);
+  const generateVideo = useCallback(async (prompt) => {
+    if (!videoAction) throw new Error("generateVideoAction not provided");
+    setIsLoading(true);
+    setError(null);
+    try {
+      const result = await videoAction({ prompt });
+      setLastResult(result);
+      setLastType("video");
+      return result;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Video generation failed";
+      setError(msg);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [videoAction]);
+  const clearError = useCallback(() => setError(null), []);
+  return {
+    generateText,
+    generateImage,
+    generateAudio,
+    transcribeAudio,
+    generateVideo,
+    isLoading,
+    error,
+    lastResult,
+    lastType,
+    clearError
+  };
+}
+
+// src/hooks/useChat.ts
+import { useState as useState2, useCallback as useCallback2 } from "react";
+import { useQuery, useMutation, useAction as useAction2 } from "convex/react";
+function useChat(options = {}) {
+  const [localMessages, setLocalMessages] = useState2([]);
+  const [isSending, setIsSending] = useState2(false);
+  const [error, setError] = useState2(null);
+  const [conversationId, setConversationId] = useState2(options.conversationId ?? null);
+  const convexMessages = options.listMessagesQuery && conversationId ? useQuery(options.listMessagesQuery, { conversationId }) : void 0;
+  const sendMutation = options.sendMessageMutation ? useMutation(options.sendMessageMutation) : null;
+  const createConversation = options.createConversationMutation ? useMutation(options.createConversationMutation) : null;
+  const textAction = options.generateTextAction ? useAction2(options.generateTextAction) : null;
+  const messages = convexMessages ?? localMessages;
+  const sendMessage = useCallback2(async (content) => {
+    setIsSending(true);
+    setError(null);
+    try {
+      let activeConversationId = conversationId;
+      if (!activeConversationId && createConversation) {
+        activeConversationId = await createConversation({
+          title: content.substring(0, 100),
+          model: options.model ?? "gpt-4o",
+          systemPrompt: options.systemPrompt
+        });
+        setConversationId(activeConversationId);
+        if (activeConversationId) options.onNewConversation?.(activeConversationId);
+      }
+      if (sendMutation && activeConversationId) {
+        await sendMutation({ conversationId: activeConversationId, content });
+      } else {
+        const userMsg = {
+          id: `msg-${Date.now()}`,
+          conversationId: activeConversationId ?? "local",
+          userId: "local",
+          role: "user",
+          content,
+          createdAt: Date.now()
+        };
+        setLocalMessages((prev) => [...prev, userMsg]);
+      }
+      if (textAction) {
+        const aiResponse = await textAction({
+          model: options.model ?? "gpt-4o",
+          messages: [
+            ...options.systemPrompt ? [{ role: "system", content: options.systemPrompt }] : [],
+            ...messages.map((m) => ({ role: m.role, content: m.content })),
+            { role: "user", content }
+          ],
+          caller: "chat"
+        });
+        if (!sendMutation) {
+          const assistantMsg = {
+            id: `msg-${Date.now()}-ai`,
+            conversationId: activeConversationId ?? "local",
+            userId: "ai",
+            role: "assistant",
+            content: aiResponse,
+            model: options.model ?? "gpt-4o",
+            createdAt: Date.now()
+          };
+          setLocalMessages((prev) => [...prev, assistantMsg]);
+        }
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Failed to send message";
+      setError(msg);
+    } finally {
+      setIsSending(false);
+    }
+  }, [conversationId, sendMutation, createConversation, textAction, messages, options]);
+  const clearError = useCallback2(() => setError(null), []);
+  return {
+    messages,
+    isLoading: convexMessages === void 0 && !!options.listMessagesQuery,
+    isSending,
+    error,
+    sendMessage,
+    conversationId,
+    clearError
+  };
+}
+
+// src/hooks/useAILogs.ts
+import { useQuery as useQuery2 } from "convex/react";
+function useAILogs(options) {
+  const logs = useQuery2(options.listLogsQuery, {
+    model: options.filters?.model,
+    provider: options.filters?.provider,
+    status: options.filters?.status,
+    caller: options.filters?.caller,
+    limit: options.limit ?? 50
+  });
+  return {
+    logs: logs ?? [],
+    isLoading: logs === void 0
+  };
+}
+
+// src/hooks/useModelTest.ts
+import { useState as useState3, useCallback as useCallback3 } from "react";
+import { useAction as useAction3 } from "convex/react";
+function useModelTest(options = {}) {
+  const [results, setResults] = useState3([]);
+  const [isRunning, setIsRunning] = useState3(false);
+  const textAction = options.generateTextAction ? useAction3(options.generateTextAction) : null;
+  const imageAction = options.generateImageAction ? useAction3(options.generateImageAction) : null;
+  const audioAction = options.generateAudioAction ? useAction3(options.generateAudioAction) : null;
+  const transcribeAction = options.transcribeAudioAction ? useAction3(options.transcribeAudioAction) : null;
+  const videoAction = options.generateVideoAction ? useAction3(options.generateVideoAction) : null;
+  const runTest = useCallback3(async (model, prompt, type = "text") => {
+    setIsRunning(true);
+    const start = Date.now();
+    try {
+      let result = "";
+      switch (type) {
+        case "text":
+          if (!textAction) throw new Error("generateTextAction not provided");
+          result = await textAction({
+            model,
+            messages: [{ role: "user", content: prompt }],
+            caller: "model-test"
+          });
+          break;
+        case "image":
+          if (!imageAction) throw new Error("generateImageAction not provided");
+          result = await imageAction({ prompt, model });
+          break;
+        case "audio":
+          if (!audioAction) throw new Error("generateAudioAction not provided");
+          result = await audioAction({ prompt });
+          break;
+        case "video":
+          if (!videoAction) throw new Error("generateVideoAction not provided");
+          result = await videoAction({ prompt });
+          break;
+        default:
+          throw new Error(`Unsupported test type: ${type}`);
+      }
+      const testResult = {
+        model,
+        type,
+        result,
+        durationMs: Date.now() - start,
+        timestamp: Date.now()
+      };
+      setResults((prev) => [...prev, testResult]);
+      return testResult;
+    } catch (err) {
+      const testResult = {
+        model,
+        type,
+        result: "",
+        durationMs: Date.now() - start,
+        timestamp: Date.now(),
+        error: err instanceof Error ? err.message : "Test failed"
+      };
+      setResults((prev) => [...prev, testResult]);
+      return testResult;
+    } finally {
+      setIsRunning(false);
+    }
+  }, [textAction, imageAction, audioAction, videoAction]);
+  const runBatchTest = useCallback3(async (models, prompt) => {
+    setIsRunning(true);
+    const batchResults = [];
+    for (const model of models) {
+      const result = await runTest(model, prompt);
+      batchResults.push(result);
+    }
+    setIsRunning(false);
+    return batchResults;
+  }, [runTest]);
+  const clearResults = useCallback3(() => setResults([]), []);
+  return { runTest, runBatchTest, results, isRunning, clearResults };
+}
+
+// src/hooks/useAIModels.ts
+import { useQuery as useQuery3, useMutation as useMutation2 } from "convex/react";
+import { useCallback as useCallback4 } from "react";
+function useAIModels(options) {
+  const models = useQuery3(options.listModelsQuery, {});
+  const upsertMutation = options.upsertModelMutation ? useMutation2(options.upsertModelMutation) : null;
+  const upsertModel = useCallback4(async (model) => {
+    if (!upsertMutation) throw new Error("upsertModelMutation not provided");
+    await upsertMutation({
+      model: model.id,
+      provider: model.provider,
+      displayName: model.displayName,
+      inputCostPer1k: model.inputCostPer1k ?? 0,
+      outputCostPer1k: model.outputCostPer1k ?? 0,
+      capabilities: model.capabilities,
+      contextWindow: model.contextWindow,
+      isActive: model.isActive
+    });
+  }, [upsertMutation]);
+  return {
+    models: models ?? [],
+    isLoading: models === void 0,
+    upsertModel
+  };
+}
+
+// src/hooks/useImageGeneration.ts
+import { useState as useState4, useCallback as useCallback5 } from "react";
+import { useAction as useAction4 } from "convex/react";
+function useImageGeneration(options) {
+  const [images, setImages] = useState4([]);
+  const [isGenerating, setIsGenerating] = useState4(false);
+  const [error, setError] = useState4(null);
+  const action = useAction4(options.generateImageAction);
+  const generate = useCallback5(async (prompt, opts) => {
+    setIsGenerating(true);
+    setError(null);
+    try {
+      const model = opts?.model ?? options.defaultModel ?? "dall-e-3";
+      const result = await action({
+        prompt,
+        model,
+        negativePrompt: opts?.negativePrompt,
+        size: opts?.size ?? "1024x1024",
+        quality: opts?.quality,
+        style: opts?.style,
+        n: opts?.n ?? 1,
+        seed: opts?.seed
+      });
+      const img = {
+        url: result.startsWith("http") ? result : `data:image/png;base64,${result}`,
+        prompt,
+        model,
+        timestamp: Date.now()
+      };
+      setImages((prev) => [img, ...prev]);
+      return img.url;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Image generation failed";
+      setError(msg);
+      throw err;
+    } finally {
+      setIsGenerating(false);
+    }
+  }, [action, options.defaultModel]);
+  return {
+    generate,
+    images,
+    isGenerating,
+    error,
+    clearImages: () => setImages([]),
+    clearError: () => setError(null)
+  };
+}
+
+// src/hooks/useTextToSpeech.ts
+import { useState as useState5, useCallback as useCallback6, useRef as useRef2 } from "react";
+import { useAction as useAction5 } from "convex/react";
+function useTextToSpeech(options) {
+  const [isGenerating, setIsGenerating] = useState5(false);
+  const [isSpeaking, setIsSpeaking] = useState5(false);
+  const [error, setError] = useState5(null);
+  const [audioUrl, setAudioUrl] = useState5(null);
+  const audioRef = useRef2(null);
+  const action = useAction5(options.generateAudioAction);
+  const speak = useCallback6(async (text, opts) => {
+    setIsGenerating(true);
+    setError(null);
+    try {
+      const base64 = await action({
+        prompt: text,
+        voice: opts?.voice ?? options.defaultVoice ?? "alloy",
+        model: opts?.model ?? options.defaultModel,
+        speed: opts?.speed,
+        voiceSettings: opts?.voiceSettings
+      });
+      const url = base64.startsWith("http") ? base64 : `data:audio/mp3;base64,${base64}`;
+      setAudioUrl(url);
+      if (options.autoPlay !== false) {
+        if (audioRef.current) {
+          audioRef.current.pause();
+        }
+        const audio = new Audio(url);
+        audioRef.current = audio;
+        setIsSpeaking(true);
+        audio.onended = () => setIsSpeaking(false);
+        audio.onerror = () => {
+          setIsSpeaking(false);
+          setError("Audio playback failed");
+        };
+        await audio.play();
+      }
+      return url;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "TTS generation failed";
+      setError(msg);
+      throw err;
+    } finally {
+      setIsGenerating(false);
+    }
+  }, [action, options]);
+  const stop = useCallback6(() => {
+    if (audioRef.current) {
+      audioRef.current.pause();
+      audioRef.current = null;
+    }
+    setIsSpeaking(false);
+  }, []);
+  return {
+    speak,
+    stop,
+    isSpeaking,
+    isGenerating,
+    error,
+    audioUrl,
+    clearError: () => setError(null)
+  };
+}
+
+// src/hooks/useVideoGeneration.ts
+import { useState as useState6, useCallback as useCallback7 } from "react";
+import { useAction as useAction6 } from "convex/react";
+function useVideoGeneration(options) {
+  const [videos, setVideos] = useState6([]);
+  const [isGenerating, setIsGenerating] = useState6(false);
+  const [error, setError] = useState6(null);
+  const action = useAction6(options.generateVideoAction);
+  const generate = useCallback7(async (prompt, opts) => {
+    setIsGenerating(true);
+    setError(null);
+    try {
+      const model = opts?.model ?? options.defaultModel ?? "minimax/video-01";
+      const result = await action({
+        prompt,
+        model,
+        duration: opts?.duration,
+        aspectRatio: opts?.aspectRatio,
+        resolution: opts?.resolution,
+        startImage: opts?.startImage,
+        endImage: opts?.endImage
+      });
+      const vid = { url: result, prompt, model, timestamp: Date.now() };
+      setVideos((prev) => [vid, ...prev]);
+      return result;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Video generation failed";
+      setError(msg);
+      throw err;
+    } finally {
+      setIsGenerating(false);
+    }
+  }, [action, options.defaultModel]);
+  return {
+    generate,
+    videos,
+    isGenerating,
+    error,
+    clearVideos: () => setVideos([]),
+    clearError: () => setError(null)
+  };
+}
+
+// src/hooks/useTranscription.ts
+import { useState as useState7, useCallback as useCallback8, useRef as useRef3 } from "react";
+import { useAction as useAction7 } from "convex/react";
+function useTranscription(options) {
+  const [isTranscribing, setIsTranscribing] = useState7(false);
+  const [isRecording, setIsRecording] = useState7(false);
+  const [lastResult, setLastResult] = useState7(null);
+  const [error, setError] = useState7(null);
+  const mediaRecorderRef = useRef3(null);
+  const chunksRef = useRef3([]);
+  const action = useAction7(options.transcribeAction);
+  const transcribe = useCallback8(async (audioBase64, opts) => {
+    setIsTranscribing(true);
+    setError(null);
+    const start = Date.now();
+    try {
+      const text = await action({
+        audio: audioBase64,
+        model: opts?.model ?? options.defaultModel,
+        language: opts?.language,
+        prompt: opts?.prompt
+      });
+      setLastResult({ text, timestamp: Date.now(), durationMs: Date.now() - start });
+      return text;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Transcription failed";
+      setError(msg);
+      throw err;
+    } finally {
+      setIsTranscribing(false);
+    }
+  }, [action, options.defaultModel]);
+  const startRecording = useCallback8(async () => {
+    if (!options.enableMicrophone) throw new Error("Microphone not enabled");
+    const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+    const mediaRecorder = new MediaRecorder(stream, { mimeType: "audio/webm" });
+    chunksRef.current = [];
+    mediaRecorder.ondataavailable = (e) => {
+      if (e.data.size > 0) chunksRef.current.push(e.data);
+    };
+    mediaRecorder.start();
+    mediaRecorderRef.current = mediaRecorder;
+    setIsRecording(true);
+  }, [options.enableMicrophone]);
+  const stopRecording = useCallback8(async () => {
+    return new Promise((resolve, reject) => {
+      const recorder = mediaRecorderRef.current;
+      if (!recorder) {
+        reject(new Error("Not recording"));
+        return;
+      }
+      recorder.onstop = async () => {
+        setIsRecording(false);
+        const blob = new Blob(chunksRef.current, { type: "audio/webm" });
+        const arrayBuffer = await blob.arrayBuffer();
+        const bytes = new Uint8Array(arrayBuffer);
+        let binary = "";
+        for (let i = 0; i < bytes.length; i++) {
+          binary += String.fromCharCode(bytes[i]);
+        }
+        const base64 = btoa(binary);
+        recorder.stream.getTracks().forEach((t) => t.stop());
+        try {
+          const text = await transcribe(base64);
+          resolve(text);
+        } catch (err) {
+          reject(err);
+        }
+      };
+      recorder.stop();
+    });
+  }, [transcribe]);
+  return {
+    transcribe,
+    startRecording,
+    stopRecording,
+    isTranscribing,
+    isRecording,
+    lastResult,
+    error,
+    clearError: () => setError(null)
+  };
+}
+
+// src/hooks/useRealtimeAudio.ts
+import { useState as useState8, useCallback as useCallback9, useRef as useRef4, useEffect as useEffect2 } from "react";
+function useRealtimeAudio(options) {
+  const [isConnected, setIsConnected] = useState8(false);
+  const [isSpeaking, setIsSpeaking] = useState8(false);
+  const [isListening, setIsListening] = useState8(false);
+  const [error, setError] = useState8(null);
+  const [transcript, setTranscript] = useState8("");
+  const [response, setResponse] = useState8("");
+  const wsRef = useRef4(null);
+  const audioContextRef = useRef4(null);
+  const streamRef = useRef4(null);
+  const processorRef = useRef4(null);
+  const connect = useCallback9(async () => {
+    try {
+      setError(null);
+      let wsUrl = options.wsUrl ?? "wss://api.openai.com/v1/realtime";
+      if (options.getSessionAction) {
+        const session = await options.getSessionAction({
+          model: options.model ?? "gpt-4o-realtime-preview",
+          voice: options.voice ?? "alloy",
+          instructions: options.instructions
+        });
+        wsUrl = session.url ?? wsUrl;
+      }
+      const ws = new WebSocket(wsUrl);
+      wsRef.current = ws;
+      ws.onopen = () => {
+        setIsConnected(true);
+        ws.send(JSON.stringify({
+          type: "session.update",
+          session: {
+            model: options.model ?? "gpt-4o-realtime-preview",
+            voice: options.voice ?? "alloy",
+            instructions: options.instructions ?? "You are a helpful assistant.",
+            input_audio_format: options.inputAudioFormat ?? "pcm16",
+            output_audio_format: options.outputAudioFormat ?? "pcm16",
+            turn_detection: options.turnDetection ?? {
+              type: "server_vad",
+              threshold: 0.5,
+              prefix_padding_ms: 300,
+              silence_duration_ms: 500
+            },
+            tools: options.tools ?? []
+          }
+        }));
+        startAudioCapture(ws);
+      };
+      ws.onmessage = (event) => {
+        const data = JSON.parse(event.data);
+        options.onEvent?.(data);
+        switch (data.type) {
+          case "input_audio_buffer.speech_started":
+            setIsSpeaking(true);
+            break;
+          case "input_audio_buffer.speech_stopped":
+            setIsSpeaking(false);
+            break;
+          case "response.text.delta":
+            setResponse((prev) => prev + data.delta);
+            break;
+          case "response.text.done":
+            options.onResponse?.(data.text);
+            setResponse("");
+            break;
+          case "response.audio.delta":
+            playAudioDelta(data.delta);
+            break;
+          case "error":
+            setError(data.error.message);
+            break;
+        }
+      };
+      ws.onerror = () => setError("WebSocket connection error");
+      ws.onclose = () => {
+        setIsConnected(false);
+        setIsListening(false);
+        stopAudioCapture();
+      };
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to connect");
+    }
+  }, [options]);
+  const startAudioCapture = useCallback9(async (ws) => {
+    try {
+      const stream = await navigator.mediaDevices.getUserMedia({ audio: { sampleRate: 24e3, channelCount: 1 } });
+      streamRef.current = stream;
+      const audioCtx = new AudioContext({ sampleRate: 24e3 });
+      audioContextRef.current = audioCtx;
+      const source = audioCtx.createMediaStreamSource(stream);
+      const processor = audioCtx.createScriptProcessor(4096, 1, 1);
+      processorRef.current = processor;
+      processor.onaudioprocess = (e) => {
+        if (ws.readyState !== WebSocket.OPEN) return;
+        const inputData = e.inputBuffer.getChannelData(0);
+        const pcm16 = new Int16Array(inputData.length);
+        for (let i = 0; i < inputData.length; i++) {
+          const s = Math.max(-1, Math.min(1, inputData[i]));
+          pcm16[i] = s < 0 ? s * 32768 : s * 32767;
+        }
+        const bytes = new Uint8Array(pcm16.buffer);
+        let binary = "";
+        for (let i = 0; i < bytes.length; i++) {
+          binary += String.fromCharCode(bytes[i]);
+        }
+        ws.send(JSON.stringify({
+          type: "input_audio_buffer.append",
+          audio: btoa(binary)
+        }));
+      };
+      source.connect(processor);
+      processor.connect(audioCtx.destination);
+      setIsListening(true);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Microphone access denied");
+    }
+  }, []);
+  const stopAudioCapture = useCallback9(() => {
+    processorRef.current?.disconnect();
+    processorRef.current = null;
+    streamRef.current?.getTracks().forEach((t) => t.stop());
+    streamRef.current = null;
+    audioContextRef.current?.close();
+    audioContextRef.current = null;
+    setIsListening(false);
+  }, []);
+  const playAudioDelta = useCallback9((_delta) => {
+  }, []);
+  const disconnect = useCallback9(() => {
+    wsRef.current?.close();
+    wsRef.current = null;
+    stopAudioCapture();
+    setIsConnected(false);
+  }, [stopAudioCapture]);
+  useEffect2(() => {
+    return () => {
+      disconnect();
+    };
+  }, []);
+  return {
+    connect,
+    disconnect,
+    isConnected,
+    isSpeaking,
+    isListening,
+    error,
+    transcript,
+    response,
+    clearError: () => setError(null)
+  };
+}
+
+// src/hooks/useContentManager.ts
+import { useState as useState9, useCallback as useCallback10 } from "react";
+function useContentManager(options) {
+  const { generateFn, defaultType = "text", defaultTone, defaultModel } = options;
+  const [result, setResult] = useState9(null);
+  const [isGenerating, setIsGenerating] = useState9(false);
+  const [error, setError] = useState9(null);
+  const execute = useCallback10(async (action, input, extra) => {
+    setIsGenerating(true);
+    setError(null);
+    try {
+      const res = await generateFn({
+        action,
+        input,
+        type: extra?.type ?? defaultType,
+        tone: extra?.tone ?? defaultTone,
+        model: extra?.model ?? defaultModel,
+        ...extra
+      });
+      setResult(res);
+      return res;
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      setError(e);
+      throw e;
+    } finally {
+      setIsGenerating(false);
+    }
+  }, [generateFn, defaultType, defaultTone, defaultModel]);
+  const generate = useCallback10((input, opts) => execute("generate", input, opts), [execute]);
+  const rewrite = useCallback10((text, instructions) => execute("rewrite", text, { instructions }), [execute]);
+  const translate = useCallback10((text, language) => execute("translate", text, { language }), [execute]);
+  const summarize = useCallback10((text) => execute("summarize", text), [execute]);
+  const variations = useCallback10((text, count = 3) => execute("variations", text, { variations: count }), [execute]);
+  const changeTone = useCallback10((text, tone) => execute("change-tone", text, { tone }), [execute]);
+  const proofread = useCallback10((text) => execute("proofread", text), [execute]);
+  const reset = useCallback10(() => {
+    setResult(null);
+    setError(null);
+  }, []);
+  return {
+    generate,
+    rewrite,
+    translate,
+    summarize,
+    variations,
+    changeTone,
+    proofread,
+    result,
+    isGenerating,
+    error,
+    reset
+  };
+}
+
+// src/hooks/useMemory.ts
+import { useState as useState10, useCallback as useCallback11 } from "react";
+function useMemory(options) {
+  const {
+    storeFn,
+    searchFn,
+    deleteFn,
+    clearFn,
+    defaultNamespace = "user",
+    defaultScopeId = ""
+  } = options;
+  const [memories, setMemories] = useState10([]);
+  const [isLoading, setIsLoading] = useState10(false);
+  const [error, setError] = useState10(null);
+  const store = useCallback11(async (key, value, opts) => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const entry = await storeFn({
+        namespace: opts?.namespace ?? defaultNamespace,
+        type: opts?.type ?? "fact",
+        importance: opts?.importance ?? "medium",
+        key,
+        value,
+        metadata: opts?.metadata,
+        scopeId: opts?.scopeId ?? defaultScopeId
+      });
+      setMemories((prev) => [...prev, entry]);
+      return entry;
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      setError(e);
+      throw e;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [storeFn, defaultNamespace, defaultScopeId]);
+  const recall = useCallback11(async (key, namespace) => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const results = await searchFn({
+        namespace: namespace ?? defaultNamespace,
+        key,
+        scopeId: defaultScopeId,
+        limit: 1
+      });
+      return results.length > 0 ? results[0] : null;
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      setError(e);
+      throw e;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [searchFn, defaultNamespace, defaultScopeId]);
+  const search = useCallback11(async (query) => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const results = await searchFn({
+        scopeId: defaultScopeId,
+        ...query
+      });
+      setMemories(results);
+      return results;
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      setError(e);
+      throw e;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [searchFn, defaultScopeId]);
+  const remove = useCallback11(async (id) => {
+    setError(null);
+    try {
+      await deleteFn(id);
+      setMemories((prev) => prev.filter((m) => m.id !== id));
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      setError(e);
+      throw e;
+    }
+  }, [deleteFn]);
+  const clear = useCallback11(async (namespace) => {
+    setError(null);
+    try {
+      await clearFn(namespace ?? defaultNamespace, defaultScopeId);
+      setMemories([]);
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      setError(e);
+      throw e;
+    }
+  }, [clearFn, defaultNamespace, defaultScopeId]);
+  return { store, recall, search, remove, clear, memories, isLoading, error };
+}
+
+// src/hooks/useSkills.ts
+import { useState as useState11, useCallback as useCallback12, useMemo } from "react";
+import { BUILT_IN_SKILLS } from "@geenius/ai-shared";
+function useSkills(options) {
+  const { executeFn, customSkills = [], defaultModel, userId } = options;
+  const [result, setResult] = useState11(null);
+  const [isExecuting, setIsExecuting] = useState11(false);
+  const [error, setError] = useState11(null);
+  const allSkills = useMemo(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const skill of Object.values(BUILT_IN_SKILLS)) map.set(skill.id, skill);
+    for (const skill of customSkills) map.set(skill.id, skill);
+    return Array.from(map.values());
+  }, [customSkills]);
+  const byCategory = useCallback12((category) => allSkills.filter((s) => s.category === category), [allSkills]);
+  const searchSkills = useCallback12((query) => {
+    const q = query.toLowerCase();
+    return allSkills.filter(
+      (s) => s.name.toLowerCase().includes(q) || s.description.toLowerCase().includes(q) || s.tags?.some((t) => t.toLowerCase().includes(q))
+    );
+  }, [allSkills]);
+  const getSkill = useCallback12((id) => allSkills.find((s) => s.id === id), [allSkills]);
+  const execute = useCallback12(async (skillId, params, context) => {
+    setIsExecuting(true);
+    setError(null);
+    try {
+      const res = await executeFn({
+        skillId,
+        params,
+        userId,
+        context,
+        model: defaultModel
+      });
+      setResult(res);
+      return res;
+    } catch (err) {
+      const e = err instanceof Error ? err : new Error(String(err));
+      setError(e);
+      throw e;
+    } finally {
+      setIsExecuting(false);
+    }
+  }, [executeFn, userId, defaultModel]);
+  const reset = useCallback12(() => {
+    setResult(null);
+    setError(null);
+  }, []);
+  return {
+    skills: allSkills,
+    byCategory,
+    search: searchSkills,
+    getSkill,
+    execute,
+    result,
+    isExecuting,
+    error,
+    reset
+  };
+}
+
+// src/components/ChatWindow.tsx
+import { useState as useState12, useRef as useRef6, useEffect as useEffect3 } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function ChatWindow(props) {
+  const [input, setInput] = useState12("");
+  const messagesEndRef = useRef6(null);
+  const chat = useChat(props);
+  useEffect3(() => {
+    messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
+  }, [chat.messages.length]);
+  const handleSubmit = async (e) => {
+    e?.preventDefault();
+    if (!input.trim() || chat.isSending) return;
+    const content = input.trim();
+    setInput("");
+    await chat.sendMessage(content);
+  };
+  return /* @__PURE__ */ jsxs("div", { className: props.className, "data-ai-component": "chat-window", children: [
+    /* @__PURE__ */ jsxs("div", { "data-ai-messages": true, children: [
+      chat.messages.length === 0 && /* @__PURE__ */ jsx("div", { "data-ai-empty": true, children: /* @__PURE__ */ jsx("p", { children: "Start a conversation" }) }),
+      chat.messages.map(
+        (msg) => props.renderMessage ? props.renderMessage(msg) : /* @__PURE__ */ jsxs(
+          "div",
+          {
+            "data-ai-message": true,
+            "data-ai-role": msg.role,
+            children: [
+              /* @__PURE__ */ jsx("div", { "data-ai-message-role": true, children: msg.role }),
+              /* @__PURE__ */ jsx("div", { "data-ai-message-content": true, children: msg.content }),
+              msg.tokens && /* @__PURE__ */ jsxs("span", { "data-ai-message-tokens": true, children: [
+                msg.tokens,
+                " tokens"
+              ] })
+            ]
+          },
+          msg.id
+        )
+      ),
+      chat.isSending && /* @__PURE__ */ jsx("div", { "data-ai-message": true, "data-ai-role": "assistant", "data-ai-loading": true, children: /* @__PURE__ */ jsxs("div", { "data-ai-typing-indicator": true, children: [
+        /* @__PURE__ */ jsx("span", {}),
+        /* @__PURE__ */ jsx("span", {}),
+        /* @__PURE__ */ jsx("span", {})
+      ] }) }),
+      /* @__PURE__ */ jsx("div", { ref: messagesEndRef })
+    ] }),
+    chat.error && /* @__PURE__ */ jsxs("div", { "data-ai-error": true, role: "alert", children: [
+      /* @__PURE__ */ jsx("span", { children: chat.error }),
+      /* @__PURE__ */ jsx("button", { onClick: chat.clearError, "data-ai-dismiss": true, children: "\xD7" })
+    ] }),
+    props.renderInput ? props.renderInput({
+      value: input,
+      onChange: setInput,
+      onSubmit: handleSubmit,
+      isSending: chat.isSending
+    }) : /* @__PURE__ */ jsxs("form", { onSubmit: handleSubmit, "data-ai-input-form": true, children: [
+      /* @__PURE__ */ jsx(
+        "textarea",
+        {
+          value: input,
+          onChange: (e) => setInput(e.target.value),
+          placeholder: "Type a message\u2026",
+          disabled: chat.isSending,
+          "data-ai-input": true,
+          onKeyDown: (e) => {
+            if (e.key === "Enter" && !e.shiftKey) {
+              e.preventDefault();
+              handleSubmit();
+            }
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          type: "submit",
+          disabled: chat.isSending || !input.trim(),
+          "data-ai-send": true,
+          children: chat.isSending ? "Sending\u2026" : "Send"
+        }
+      )
+    ] })
+  ] });
+}
+
+// src/components/ModelSelector.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function ModelSelector(props) {
+  const filtered = props.filterProvider ? props.models.filter((m) => m.provider === props.filterProvider) : props.models;
+  const activeModels = filtered.filter((m) => m.isActive);
+  return /* @__PURE__ */ jsxs2(
+    "select",
+    {
+      className: props.className,
+      value: props.selectedModel ?? "",
+      onChange: (e) => props.onSelect(e.target.value),
+      disabled: props.disabled,
+      "data-ai-component": "model-selector",
+      children: [
+        /* @__PURE__ */ jsx2("option", { value: "", disabled: true, children: "Select a model\u2026" }),
+        activeModels.map((model) => /* @__PURE__ */ jsxs2("option", { value: model.id, "data-ai-provider": model.provider, children: [
+          model.displayName ?? model.name,
+          props.showCost ? ` ($${model.inputCostPer1k}/$${model.outputCostPer1k}/1k)` : ""
+        ] }, model.id))
+      ]
+    }
+  );
+}
+
+// src/components/AILogTable.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function formatDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  return `${(ms / 1e3).toFixed(1)}s`;
+}
+function formatCost(usd) {
+  if (!usd) return "\u2014";
+  if (usd < 0.01) return `$${usd.toFixed(4)}`;
+  return `$${usd.toFixed(2)}`;
+}
+function StatusBadge({ status }) {
+  return /* @__PURE__ */ jsxs3("span", { "data-ai-status": status, children: [
+    status === "success" ? "\u2713" : "\u2717",
+    " ",
+    status
+  ] });
+}
+function AILogTable(props) {
+  if (props.isLoading) {
+    return /* @__PURE__ */ jsx3("div", { "data-ai-component": "log-table", "data-ai-loading": true, children: "Loading logs\u2026" });
+  }
+  if (props.logs.length === 0) {
+    return /* @__PURE__ */ jsx3("div", { "data-ai-component": "log-table", "data-ai-empty": true, children: "No AI logs yet" });
+  }
+  return /* @__PURE__ */ jsx3("div", { className: props.className, "data-ai-component": "log-table", children: /* @__PURE__ */ jsxs3("table", { "data-ai-table": true, children: [
+    /* @__PURE__ */ jsx3("thead", { children: /* @__PURE__ */ jsxs3("tr", { children: [
+      /* @__PURE__ */ jsx3("th", { children: "Time" }),
+      /* @__PURE__ */ jsx3("th", { children: "Model" }),
+      /* @__PURE__ */ jsx3("th", { children: "Provider" }),
+      /* @__PURE__ */ jsx3("th", { children: "Caller" }),
+      /* @__PURE__ */ jsx3("th", { children: "Status" }),
+      /* @__PURE__ */ jsx3("th", { children: "Duration" }),
+      /* @__PURE__ */ jsx3("th", { children: "Tokens" }),
+      /* @__PURE__ */ jsx3("th", { children: "Cost" })
+    ] }) }),
+    /* @__PURE__ */ jsx3("tbody", { children: props.logs.map((log) => /* @__PURE__ */ jsxs3(
+      "tr",
+      {
+        onClick: () => props.onRowClick?.(log),
+        "data-ai-log-row": true,
+        "data-ai-status": log.status,
+        children: [
+          /* @__PURE__ */ jsx3("td", { "data-ai-cell": "time", children: new Date(log.timestamp).toLocaleTimeString() }),
+          /* @__PURE__ */ jsx3("td", { "data-ai-cell": "model", children: log.model }),
+          /* @__PURE__ */ jsx3("td", { "data-ai-cell": "provider", children: log.provider }),
+          /* @__PURE__ */ jsx3("td", { "data-ai-cell": "caller", children: log.caller }),
+          /* @__PURE__ */ jsx3("td", { "data-ai-cell": "status", children: /* @__PURE__ */ jsx3(StatusBadge, { status: log.status }) }),
+          /* @__PURE__ */ jsx3("td", { "data-ai-cell": "duration", children: formatDuration(log.durationMs) }),
+          /* @__PURE__ */ jsx3("td", { "data-ai-cell": "tokens", children: log.totalTokens ?? "\u2014" }),
+          /* @__PURE__ */ jsx3("td", { "data-ai-cell": "cost", children: formatCost(log.totalCostUsd) })
+        ]
+      },
+      log.requestId
+    )) })
+  ] }) });
+}
+
+// src/components/ModelTestRunner.tsx
+import { useState as useState13 } from "react";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var TABS = [
+  { id: "text", label: "Text Generation" },
+  { id: "image", label: "Image Generation" },
+  { id: "audio", label: "Text-to-Speech" },
+  { id: "transcription", label: "Audio-to-Text" },
+  { id: "video", label: "Video Generation" }
+];
+function ModelTestRunner(props) {
+  const [activeTab, setActiveTab] = useState13(props.defaultTab ?? "text");
+  const [prompt, setPrompt] = useState13("");
+  const [selectedModel, setSelectedModel] = useState13("");
+  const [batchMode, setBatchMode] = useState13(false);
+  const test = useModelTest(props);
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    if (!prompt.trim()) return;
+    if (batchMode && props.availableModels) {
+      await test.runBatchTest(props.availableModels, prompt.trim());
+    } else if (selectedModel) {
+      await test.runTest(selectedModel, prompt.trim(), activeTab);
+    }
+  };
+  return /* @__PURE__ */ jsxs4("div", { className: props.className, "data-ai-component": "model-test-runner", children: [
+    /* @__PURE__ */ jsx4("div", { "data-ai-tabs": true, role: "tablist", children: TABS.map((tab) => /* @__PURE__ */ jsx4(
+      "button",
+      {
+        role: "tab",
+        "aria-selected": activeTab === tab.id,
+        onClick: () => setActiveTab(tab.id),
+        "data-ai-tab": true,
+        "data-ai-tab-active": activeTab === tab.id ? "" : void 0,
+        children: tab.label
+      },
+      tab.id
+    )) }),
+    /* @__PURE__ */ jsxs4("form", { onSubmit: handleSubmit, "data-ai-test-form": true, children: [
+      /* @__PURE__ */ jsxs4("div", { "data-ai-field": "model", children: [
+        /* @__PURE__ */ jsx4("label", { htmlFor: "test-model", children: "Model" }),
+        /* @__PURE__ */ jsxs4(
+          "select",
+          {
+            id: "test-model",
+            value: selectedModel,
+            onChange: (e) => setSelectedModel(e.target.value),
+            disabled: test.isRunning || batchMode,
+            "data-ai-input": true,
+            children: [
+              /* @__PURE__ */ jsx4("option", { value: "", children: "Select model\u2026" }),
+              (props.availableModels ?? []).map((m) => /* @__PURE__ */ jsx4("option", { value: m, children: m }, m))
+            ]
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs4("div", { "data-ai-field": "prompt", children: [
+        /* @__PURE__ */ jsx4("label", { htmlFor: "test-prompt", children: "Prompt" }),
+        /* @__PURE__ */ jsx4(
+          "textarea",
+          {
+            id: "test-prompt",
+            value: prompt,
+            onChange: (e) => setPrompt(e.target.value),
+            placeholder: "Enter your test prompt\u2026",
+            disabled: test.isRunning,
+            "data-ai-input": true
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs4("div", { "data-ai-actions": true, children: [
+        /* @__PURE__ */ jsxs4("label", { "data-ai-toggle": true, children: [
+          /* @__PURE__ */ jsx4(
+            "input",
+            {
+              type: "checkbox",
+              checked: batchMode,
+              onChange: (e) => setBatchMode(e.target.checked),
+              disabled: test.isRunning
+            }
+          ),
+          "Test all models"
+        ] }),
+        /* @__PURE__ */ jsx4("button", { type: "submit", disabled: test.isRunning || !prompt.trim(), "data-ai-submit": true, children: test.isRunning ? "Running\u2026" : batchMode ? "Run All" : "Run Test" }),
+        test.results.length > 0 && /* @__PURE__ */ jsx4("button", { type: "button", onClick: test.clearResults, "data-ai-clear": true, children: "Clear Results" })
+      ] })
+    ] }),
+    test.results.length > 0 && /* @__PURE__ */ jsx4("div", { "data-ai-test-results": true, children: test.results.map((result, i) => props.renderResult ? props.renderResult(result) : /* @__PURE__ */ jsxs4("div", { "data-ai-test-result": true, "data-ai-status": result.error ? "error" : "success", children: [
+      /* @__PURE__ */ jsxs4("div", { "data-ai-result-header": true, children: [
+        /* @__PURE__ */ jsx4("span", { "data-ai-result-model": true, children: result.model }),
+        /* @__PURE__ */ jsxs4("span", { "data-ai-result-duration": true, children: [
+          result.durationMs,
+          "ms"
+        ] }),
+        result.error && /* @__PURE__ */ jsx4("span", { "data-ai-result-error": true, children: result.error })
+      ] }),
+      !result.error && /* @__PURE__ */ jsx4("div", { "data-ai-result-content": true, children: result.type === "image" ? /* @__PURE__ */ jsx4(
+        "img",
+        {
+          src: result.result.startsWith("http") ? result.result : `data:image/png;base64,${result.result}`,
+          alt: "Generated",
+          "data-ai-result-image": true
+        }
+      ) : /* @__PURE__ */ jsx4("pre", { "data-ai-result-text": true, children: result.result }) })
+    ] }, i)) })
+  ] });
+}
+
+// src/components/GenerationCard.tsx
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function GenerationCard(props) {
+  return /* @__PURE__ */ jsxs5("div", { className: props.className, "data-ai-component": "generation-card", "data-ai-type": props.type, children: [
+    /* @__PURE__ */ jsxs5("div", { "data-ai-card-header": true, children: [
+      /* @__PURE__ */ jsx5("span", { "data-ai-card-type": true, children: props.type }),
+      props.model && /* @__PURE__ */ jsx5("span", { "data-ai-card-model": true, children: props.model }),
+      props.durationMs != null && /* @__PURE__ */ jsxs5("span", { "data-ai-card-duration": true, children: [
+        props.durationMs,
+        "ms"
+      ] })
+    ] }),
+    props.error ? /* @__PURE__ */ jsx5("div", { "data-ai-card-error": true, role: "alert", children: props.error }) : /* @__PURE__ */ jsx5("div", { "data-ai-card-content": true, children: props.type === "image" ? /* @__PURE__ */ jsx5(
+      "img",
+      {
+        src: props.content.startsWith("http") ? props.content : `data:image/png;base64,${props.content}`,
+        alt: "AI Generated",
+        "data-ai-card-image": true
+      }
+    ) : props.type === "audio" || props.type === "speech" ? /* @__PURE__ */ jsx5("audio", { controls: true, "data-ai-card-audio": true, children: /* @__PURE__ */ jsx5(
+      "source",
+      {
+        src: props.content.startsWith("http") ? props.content : `data:audio/mp3;base64,${props.content}`,
+        type: "audio/mp3"
+      }
+    ) }) : props.type === "video" ? /* @__PURE__ */ jsx5("video", { controls: true, "data-ai-card-video": true, children: /* @__PURE__ */ jsx5("source", { src: props.content, type: "video/mp4" }) }) : /* @__PURE__ */ jsx5("pre", { "data-ai-card-text": true, children: props.content }) }),
+    (props.tokens || props.cost != null) && /* @__PURE__ */ jsxs5("div", { "data-ai-card-footer": true, children: [
+      props.tokens && /* @__PURE__ */ jsxs5("span", { "data-ai-card-tokens": true, children: [
+        props.tokens,
+        " tokens"
+      ] }),
+      props.cost != null && /* @__PURE__ */ jsxs5("span", { "data-ai-card-cost": true, children: [
+        "$",
+        props.cost < 0.01 ? props.cost.toFixed(4) : props.cost.toFixed(2)
+      ] })
+    ] })
+  ] });
+}
+
+// src/components/ImageGenerator.tsx
+import { useState as useState14 } from "react";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function ImageGenerator(props) {
+  const [prompt, setPrompt] = useState14("");
+  const [selectedModel, setSelectedModel] = useState14(props.defaultModel ?? "");
+  const [size, setSize] = useState14("1024x1024");
+  const [quality, setQuality] = useState14("standard");
+  const { generate, images, isGenerating, error, clearImages, clearError } = useImageGeneration(props);
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    if (!prompt.trim() || isGenerating) return;
+    await generate(prompt.trim(), { model: selectedModel || void 0, size, quality });
+  };
+  return /* @__PURE__ */ jsxs6("div", { className: props.className, "data-ai-component": "image-generator", children: [
+    /* @__PURE__ */ jsxs6("form", { onSubmit: handleSubmit, "data-ai-image-form": true, children: [
+      /* @__PURE__ */ jsx6("div", { "data-ai-field": "prompt", children: /* @__PURE__ */ jsx6(
+        "textarea",
+        {
+          value: prompt,
+          onChange: (e) => setPrompt(e.target.value),
+          placeholder: "Describe the image you want to create\u2026",
+          disabled: isGenerating,
+          "data-ai-input": true
+        }
+      ) }),
+      /* @__PURE__ */ jsxs6("div", { "data-ai-image-options": true, children: [
+        props.availableModels && /* @__PURE__ */ jsxs6(
+          "select",
+          {
+            value: selectedModel,
+            onChange: (e) => setSelectedModel(e.target.value),
+            disabled: isGenerating,
+            "data-ai-select": true,
+            children: [
+              /* @__PURE__ */ jsx6("option", { value: "", children: "Default model" }),
+              props.availableModels.map((m) => /* @__PURE__ */ jsx6("option", { value: m, children: m }, m))
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs6("select", { value: size, onChange: (e) => setSize(e.target.value), disabled: isGenerating, "data-ai-select": true, children: [
+          /* @__PURE__ */ jsx6("option", { value: "1024x1024", children: "1024\xD71024" }),
+          /* @__PURE__ */ jsx6("option", { value: "1792x1024", children: "1792\xD71024" }),
+          /* @__PURE__ */ jsx6("option", { value: "1024x1792", children: "1024\xD71792" }),
+          /* @__PURE__ */ jsx6("option", { value: "512x512", children: "512\xD7512" })
+        ] }),
+        /* @__PURE__ */ jsxs6("select", { value: quality, onChange: (e) => setQuality(e.target.value), disabled: isGenerating, "data-ai-select": true, children: [
+          /* @__PURE__ */ jsx6("option", { value: "standard", children: "Standard" }),
+          /* @__PURE__ */ jsx6("option", { value: "hd", children: "HD" })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs6("div", { "data-ai-actions": true, children: [
+        /* @__PURE__ */ jsx6("button", { type: "submit", disabled: isGenerating || !prompt.trim(), "data-ai-submit": true, children: isGenerating ? "Generating\u2026" : "Generate Image" }),
+        images.length > 0 && /* @__PURE__ */ jsx6("button", { type: "button", onClick: clearImages, "data-ai-clear": true, children: "Clear Gallery" })
+      ] })
+    ] }),
+    error && /* @__PURE__ */ jsxs6("div", { "data-ai-error": true, role: "alert", children: [
+      /* @__PURE__ */ jsx6("span", { children: error }),
+      /* @__PURE__ */ jsx6("button", { onClick: clearError, children: "\xD7" })
+    ] }),
+    images.length > 0 && /* @__PURE__ */ jsx6("div", { "data-ai-image-gallery": true, children: images.map((img, i) => /* @__PURE__ */ jsxs6("div", { "data-ai-image-card": true, children: [
+      /* @__PURE__ */ jsx6("img", { src: img.url, alt: img.prompt, "data-ai-generated-image": true }),
+      /* @__PURE__ */ jsxs6("div", { "data-ai-image-meta": true, children: [
+        /* @__PURE__ */ jsx6("span", { "data-ai-image-model": true, children: img.model }),
+        /* @__PURE__ */ jsx6("span", { "data-ai-image-time": true, children: new Date(img.timestamp).toLocaleTimeString() })
+      ] })
+    ] }, i)) })
+  ] });
+}
+
+// src/components/VoiceSelector.tsx
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+function VoiceSelector(props) {
+  return /* @__PURE__ */ jsx7("div", { className: props.className, "data-ai-component": "voice-selector", children: props.voices.map((voice) => /* @__PURE__ */ jsxs7(
+    "button",
+    {
+      onClick: () => props.onSelect(voice.id),
+      disabled: props.disabled,
+      "data-ai-voice": true,
+      "data-ai-voice-selected": props.selectedVoice === voice.id ? "" : void 0,
+      "data-ai-provider": voice.provider,
+      children: [
+        /* @__PURE__ */ jsx7("span", { "data-ai-voice-name": true, children: voice.name }),
+        voice.gender && /* @__PURE__ */ jsx7("span", { "data-ai-voice-gender": true, children: voice.gender }),
+        voice.language && /* @__PURE__ */ jsx7("span", { "data-ai-voice-language": true, children: voice.language }),
+        props.showProvider && /* @__PURE__ */ jsx7("span", { "data-ai-voice-provider": true, children: voice.provider }),
+        props.showPreview && voice.preview && /* @__PURE__ */ jsx7(
+          "button",
+          {
+            "data-ai-voice-preview": true,
+            onClick: (e) => {
+              e.stopPropagation();
+              props.onPreview?.(voice.id);
+            },
+            children: "\u25B6"
+          }
+        )
+      ]
+    },
+    voice.id
+  )) });
+}
+
+// src/pages/ChatPage.tsx
+import { useState as useState15 } from "react";
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+function ChatPage(props) {
+  const [activeConversationId, setActiveConversationId] = useState15(props.conversationId);
+  return /* @__PURE__ */ jsxs8("div", { className: props.className, "data-ai-page": "chat", children: [
+    /* @__PURE__ */ jsxs8("div", { "data-ai-page-header": true, children: [
+      /* @__PURE__ */ jsx8("h1", { "data-ai-page-title": true, children: "AI Chat" }),
+      /* @__PURE__ */ jsx8(
+        "button",
+        {
+          onClick: () => setActiveConversationId(void 0),
+          "data-ai-new-chat": true,
+          children: "New Chat"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx8(
+      ChatWindow,
+      {
+        ...props,
+        conversationId: activeConversationId,
+        onNewConversation: (id) => {
+          setActiveConversationId(id);
+          props.onNewConversation?.(id);
+        }
+      }
+    )
+  ] });
+}
+
+// src/pages/ModelTestPage.tsx
+import { DEFAULT_MODELS } from "@geenius/ai-shared";
+import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
+function ModelTestPage(props) {
+  const models = props.availableModels ?? DEFAULT_MODELS.map((m) => m.id);
+  return /* @__PURE__ */ jsxs9("div", { className: props.className, "data-ai-page": "model-test", children: [
+    /* @__PURE__ */ jsxs9("div", { "data-ai-page-header": true, children: [
+      /* @__PURE__ */ jsx9("h1", { "data-ai-page-title": true, children: props.title ?? "Model Test Lab" }),
+      /* @__PURE__ */ jsx9("p", { "data-ai-page-subtitle": true, children: "Test AI models individually or compare them side-by-side" })
+    ] }),
+    /* @__PURE__ */ jsx9(
+      ModelTestRunner,
+      {
+        ...props,
+        availableModels: models
+      }
+    )
+  ] });
+}
+
+// src/pages/AILogsPage.tsx
+import { useState as useState16 } from "react";
+import { jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
+function AILogsPage(props) {
+  const [modelFilter, setModelFilter] = useState16("");
+  const [statusFilter, setStatusFilter] = useState16("");
+  const { logs, isLoading } = useAILogs({
+    listLogsQuery: props.listLogsQuery,
+    filters: {
+      model: modelFilter || void 0,
+      status: statusFilter || void 0
+    },
+    limit: 100
+  });
+  const totalCalls = logs.length;
+  const successCalls = logs.filter((l) => l.status === "success").length;
+  const errorCalls = totalCalls - successCalls;
+  const totalCost = logs.reduce((sum, l) => sum + (l.totalCostUsd ?? 0), 0);
+  const totalTokens = logs.reduce((sum, l) => sum + (l.totalTokens ?? 0), 0);
+  return /* @__PURE__ */ jsxs10("div", { className: props.className, "data-ai-page": "logs", children: [
+    /* @__PURE__ */ jsx10("div", { "data-ai-page-header": true, children: /* @__PURE__ */ jsx10("h1", { "data-ai-page-title": true, children: props.title ?? "AI Logs" }) }),
+    /* @__PURE__ */ jsxs10("div", { "data-ai-stats-grid": true, children: [
+      /* @__PURE__ */ jsxs10("div", { "data-ai-stat": true, children: [
+        /* @__PURE__ */ jsx10("span", { "data-ai-stat-label": true, children: "Total Calls" }),
+        /* @__PURE__ */ jsx10("span", { "data-ai-stat-value": true, children: totalCalls })
+      ] }),
+      /* @__PURE__ */ jsxs10("div", { "data-ai-stat": true, "data-ai-status": "success", children: [
+        /* @__PURE__ */ jsx10("span", { "data-ai-stat-label": true, children: "Success" }),
+        /* @__PURE__ */ jsx10("span", { "data-ai-stat-value": true, children: successCalls })
+      ] }),
+      /* @__PURE__ */ jsxs10("div", { "data-ai-stat": true, "data-ai-status": "error", children: [
+        /* @__PURE__ */ jsx10("span", { "data-ai-stat-label": true, children: "Errors" }),
+        /* @__PURE__ */ jsx10("span", { "data-ai-stat-value": true, children: errorCalls })
+      ] }),
+      /* @__PURE__ */ jsxs10("div", { "data-ai-stat": true, children: [
+        /* @__PURE__ */ jsx10("span", { "data-ai-stat-label": true, children: "Total Cost" }),
+        /* @__PURE__ */ jsxs10("span", { "data-ai-stat-value": true, children: [
+          "$",
+          totalCost.toFixed(2)
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs10("div", { "data-ai-stat": true, children: [
+        /* @__PURE__ */ jsx10("span", { "data-ai-stat-label": true, children: "Total Tokens" }),
+        /* @__PURE__ */ jsx10("span", { "data-ai-stat-value": true, children: totalTokens.toLocaleString() })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs10("div", { "data-ai-filters": true, children: [
+      /* @__PURE__ */ jsx10(
+        "input",
+        {
+          type: "text",
+          placeholder: "Filter by model\u2026",
+          value: modelFilter,
+          onChange: (e) => setModelFilter(e.target.value),
+          "data-ai-filter-input": true
+        }
+      ),
+      /* @__PURE__ */ jsxs10(
+        "select",
+        {
+          value: statusFilter,
+          onChange: (e) => setStatusFilter(e.target.value),
+          "data-ai-filter-select": true,
+          children: [
+            /* @__PURE__ */ jsx10("option", { value: "", children: "All statuses" }),
+            /* @__PURE__ */ jsx10("option", { value: "success", children: "Success" }),
+            /* @__PURE__ */ jsx10("option", { value: "error", children: "Error" })
+          ]
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx10(
+      AILogTable,
+      {
+        logs,
+        isLoading,
+        onRowClick: props.onRowClick
+      }
+    )
+  ] });
+}
+export {
+  AILogTable,
+  AILogsPage,
+  ChatPage,
+  ChatWindow,
+  GenerationCard,
+  ImageGenerator,
+  ModelSelector,
+  ModelTestPage,
+  ModelTestRunner,
+  VoiceSelector,
+  useAI,
+  useAILogs,
+  useAIModels,
+  useChat,
+  useContentManager,
+  useImageGeneration,
+  useMemory,
+  useModelTest,
+  useRealtimeAudio,
+  useSkills,
+  useTextToSpeech,
+  useTranscription,
+  useVideoGeneration
+};
+//# sourceMappingURL=index.js.map