expo-ai-core 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1345 @@
+'use strict';
+
+var react = require('react');
+var reactNative = require('react-native');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/hooks/useAIChat.ts
+
+// src/utils/helpers.ts
+function createId(prefix = "msg") {
+  const randomPart = Math.random().toString(36).slice(2, 10);
+  const timePart = Date.now().toString(36);
+  if (typeof globalThis.crypto !== "undefined" && "randomUUID" in globalThis.crypto) {
+    return `${prefix}_${globalThis.crypto.randomUUID()}`;
+  }
+  return `${prefix}_${timePart}_${randomPart}`;
+}
+function trimContent(value) {
+  return value.trim();
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function toConversationMessages(messages, systemPrompt) {
+  const conversation = [];
+  if (systemPrompt && systemPrompt.trim()) {
+    conversation.push({ role: "system", content: systemPrompt.trim() });
+  }
+  for (const message of messages) {
+    conversation.push({ role: message.role, content: message.content });
+  }
+  return conversation;
+}
+function mergeAssistantText(previous, nextChunk) {
+  if (!nextChunk) {
+    return previous;
+  }
+  return `${previous}${nextChunk}`;
+}
+function safeJsonParse(input, fallback) {
+  try {
+    return JSON.parse(input);
+  } catch {
+    return fallback;
+  }
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function createLogger(enabled) {
+  const prefix = "[expo-ai-core]";
+  return {
+    log: (...args) => {
+      if (enabled) {
+        console.log(prefix, ...args);
+      }
+    },
+    warn: (...args) => {
+      if (enabled) {
+        console.warn(prefix, ...args);
+      }
+    },
+    error: (...args) => {
+      if (enabled) {
+        console.error(prefix, ...args);
+      }
+    }
+  };
+}
+function buildDefaultCacheKey(provider, model) {
+  return `expo-ai-core:${provider}:${model ?? "default"}`;
+}
+function toPlainText(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(toPlainText).join("");
+  }
+  if (value && typeof value === "object") {
+    const record = value;
+    if (typeof record.text === "string") {
+      return record.text;
+    }
+    if (typeof record.content === "string") {
+      return record.content;
+    }
+  }
+  return "";
+}
+
+// src/providers/shared.ts
+function createRequestController(signal, timeoutMs) {
+  const controller = new AbortController();
+  let timeoutId = null;
+  const abortFromExternal = () => {
+    if (!controller.signal.aborted) {
+      controller.abort(signal?.reason ?? new Error("Request aborted"));
+    }
+  };
+  if (signal) {
+    if (signal.aborted) {
+      abortFromExternal();
+    } else {
+      signal.addEventListener("abort", abortFromExternal, { once: true });
+    }
+  }
+  if (typeof timeoutMs === "number" && timeoutMs > 0) {
+    timeoutId = setTimeout(() => {
+      if (!controller.signal.aborted) {
+        controller.abort(new Error(`Request timed out after ${timeoutMs}ms`));
+      }
+    }, timeoutMs);
+  }
+  return {
+    signal: controller.signal,
+    abort: (reason) => controller.abort(reason),
+    cleanup: () => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      if (signal) {
+        signal.removeEventListener("abort", abortFromExternal);
+      }
+    }
+  };
+}
+function getLogger(debug) {
+  return createLogger(debug);
+}
+function buildTextResult(content, raw) {
+  return { content, raw };
+}
+function createProvider(provider) {
+  return provider;
+}
+function readOpenAIContent(payload) {
+  const choice = payload?.choices?.[0];
+  return choice?.message?.content ?? choice?.delta?.content ?? "";
+}
+function readGeminiContent(payload) {
+  const candidate = payload?.candidates?.[0];
+  const parts = candidate?.content?.parts ?? [];
+  return parts.map((part) => typeof part?.text === "string" ? part.text : "").join("");
+}
+async function readStreamingBody(response, onChunk, signal) {
+  if (response.body && "getReader" in response.body) {
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    while (true) {
+      if (signal?.aborted) {
+        await reader.cancel().catch(() => void 0);
+        break;
+      }
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      if (value) {
+        onChunk(decoder.decode(value, { stream: true }));
+      }
+    }
+    const finalChunk = decoder.decode();
+    if (finalChunk) {
+      onChunk(finalChunk);
+    }
+    return;
+  }
+  const text = await response.text();
+  onChunk(text);
+}
+function consumeSseLines(chunk, buffer, onData) {
+  const combined = `${buffer}${chunk}`;
+  const lines = combined.split(/\r?\n/);
+  const nextBuffer = lines.pop() ?? "";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    if (trimmed.startsWith("data:")) {
+      onData(trimmed.slice(5).trim());
+      continue;
+    }
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      onData(trimmed);
+    }
+  }
+  return nextBuffer;
+}
+function appendToken(current, token) {
+  return `${current}${token}`;
+}
+
+// src/providers/gemini.ts
+var DEFAULT_GEMINI_MODEL = "gemini-2.5-flash";
+var GEMINI_ENDPOINT = "https://generativelanguage.googleapis.com/v1beta/models";
+function mapGeminiMessages(messages) {
+  return messages.map((message) => ({
+    role: message.role === "assistant" ? "model" : "user",
+    parts: [{ text: message.content }]
+  }));
+}
+async function requestGemini(options, request, handlers) {
+  const logger = getLogger(options.debug);
+  const controller = createRequestController(
+    request.signal,
+    request.timeoutMs ?? options.timeoutMs
+  );
+  const model = options.model ?? DEFAULT_GEMINI_MODEL;
+  const url = `${options.baseUrl ?? GEMINI_ENDPOINT}/${model}:${request.stream ? "streamGenerateContent" : "generateContent"}?key=${encodeURIComponent(options.apiKey)}`;
+  const contents = mapGeminiMessages(request.messages);
+  const body = {
+    ...options.systemPrompt ? { systemInstruction: { parts: [{ text: options.systemPrompt }] } } : null,
+    contents,
+    generationConfig: {
+      temperature: 0.7
+    }
+  };
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      signal: controller.signal,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "");
+      throw new Error(
+        errorText || `Gemini request failed with status ${response.status}`
+      );
+    }
+    if (!request.stream) {
+      const payload = await response.json();
+      const content = readGeminiContent(payload);
+      return buildTextResult(content, payload);
+    }
+    let collected = "";
+    let buffer = "";
+    await readStreamingBody(
+      response,
+      (chunk) => {
+        buffer = consumeSseLines(chunk, buffer, (data) => {
+          if (data === "[DONE]") {
+            return;
+          }
+          const payload = typeof data === "string" ? JSON.parse(data) : data;
+          const token = readGeminiContent(payload);
+          if (token) {
+            collected = appendToken(collected, token);
+            handlers?.onToken?.(token);
+          }
+        });
+      },
+      controller.signal
+    );
+    return buildTextResult(collected);
+  } catch (error) {
+    logger.error("Gemini request failed", error);
+    throw error;
+  } finally {
+    controller.cleanup();
+  }
+}
+function createGeminiProvider(options) {
+  return createProvider({
+    name: "gemini",
+    sendMessage(request) {
+      return requestGemini(options, { ...request, stream: false });
+    },
+    streamMessage(request) {
+      return requestGemini(
+        options,
+        { ...request, stream: true },
+        { onToken: request.onToken }
+      );
+    }
+  });
+}
+
+// src/providers/openai.ts
+var DEFAULT_OPENAI_MODEL = "gpt-4o-mini";
+var OPENAI_ENDPOINT = "https://api.openai.com/v1/chat/completions";
+async function requestOpenAI(options, request, handlers) {
+  const logger = getLogger(options.debug);
+  const controller = createRequestController(
+    request.signal,
+    request.timeoutMs ?? options.timeoutMs
+  );
+  const messages = options.systemPrompt ? [{ role: "system", content: options.systemPrompt }, ...request.messages] : request.messages;
+  const body = {
+    model: options.model ?? DEFAULT_OPENAI_MODEL,
+    messages,
+    stream: Boolean(request.stream)
+  };
+  try {
+    const response = await fetch(options.baseUrl ?? OPENAI_ENDPOINT, {
+      method: "POST",
+      signal: controller.signal,
+      headers: {
+        Authorization: `Bearer ${options.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "");
+      throw new Error(
+        errorText || `OpenAI request failed with status ${response.status}`
+      );
+    }
+    if (!request.stream) {
+      const payload = await response.json();
+      const content = readOpenAIContent(payload);
+      return buildTextResult(content, payload);
+    }
+    let collected = "";
+    let buffer = "";
+    await readStreamingBody(
+      response,
+      (chunk) => {
+        buffer = consumeSseLines(chunk, buffer, (data) => {
+          if (data === "[DONE]") {
+            return;
+          }
+          const payload = typeof data === "string" ? JSON.parse(data) : data;
+          const token = readOpenAIContent(payload);
+          if (token) {
+            collected = `${collected}${token}`;
+            handlers?.onToken?.(token);
+          }
+        });
+      },
+      controller.signal
+    );
+    return buildTextResult(collected);
+  } catch (error) {
+    logger.error("OpenAI request failed", error);
+    throw error;
+  } finally {
+    controller.cleanup();
+  }
+}
+function createOpenAIProvider(options) {
+  return createProvider({
+    name: "openai",
+    sendMessage(request) {
+      return requestOpenAI(options, { ...request, stream: false });
+    },
+    streamMessage(request) {
+      return requestOpenAI(
+        options,
+        { ...request, stream: true },
+        { onToken: request.onToken }
+      );
+    }
+  });
+}
+
+// src/utils/cache.ts
+var memoryStore = /* @__PURE__ */ new Map();
+var asyncStoragePromise = null;
+async function resolveStorage() {
+  if (!asyncStoragePromise) {
+    asyncStoragePromise = import('@react-native-async-storage/async-storage').then((module) => module.default ?? module).catch(() => null);
+  }
+  return asyncStoragePromise;
+}
+async function readRaw(key) {
+  const storage = await resolveStorage();
+  if (storage) {
+    return storage.getItem(key);
+  }
+  return memoryStore.get(key) ?? null;
+}
+async function writeRaw(key, value) {
+  const storage = await resolveStorage();
+  if (storage) {
+    await storage.setItem(key, value);
+    return;
+  }
+  memoryStore.set(key, value);
+}
+async function deleteRaw(key) {
+  const storage = await resolveStorage();
+  if (storage) {
+    await storage.removeItem(key);
+    return;
+  }
+  memoryStore.delete(key);
+}
+async function loadCache(key) {
+  const raw = await readRaw(key);
+  if (!raw) {
+    return null;
+  }
+  return safeJsonParse(raw, null);
+}
+async function saveCache(key, snapshot) {
+  await writeRaw(key, JSON.stringify(snapshot));
+}
+async function clearCache(key) {
+  await deleteRaw(key);
+}
+
+// src/hooks/useAIChat.ts
+function createChatProvider(options) {
+  if (options.provider === "gemini") {
+    return createGeminiProvider({
+      apiKey: options.apiKey,
+      model: options.model,
+      systemPrompt: options.systemPrompt,
+      timeoutMs: options.timeoutMs,
+      debug: options.debug
+    });
+  }
+  return createOpenAIProvider({
+    apiKey: options.apiKey,
+    model: options.model,
+    systemPrompt: options.systemPrompt,
+    timeoutMs: options.timeoutMs,
+    debug: options.debug
+  });
+}
+function useAIChat(options) {
+  const {
+    provider,
+    apiKey,
+    model,
+    systemPrompt,
+    cacheKey = buildDefaultCacheKey(provider, model),
+    initialMessages = [],
+    timeoutMs = 3e4,
+    enableCache = true,
+    debug
+  } = options;
+  const providerInstance = react.useMemo(
+    () => createChatProvider({
+      provider,
+      apiKey,
+      model,
+      systemPrompt,
+      timeoutMs,
+      debug
+    }),
+    [provider, apiKey, model, systemPrompt, timeoutMs, debug]
+  );
+  const [messages, setMessages] = react.useState(initialMessages);
+  const [input, setInput] = react.useState("");
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const messagesRef = react.useRef(messages);
+  const inputRef = react.useRef(input);
+  const abortRef = react.useRef(null);
+  const assistantIdRef = react.useRef(null);
+  const partialRef = react.useRef("");
+  const loadingRef = react.useRef(false);
+  const streamFlushScheduledRef = react.useRef(false);
+  react.useEffect(() => {
+    messagesRef.current = messages;
+  }, [messages]);
+  react.useEffect(() => {
+    inputRef.current = input;
+  }, [input]);
+  react.useEffect(() => {
+    let mounted = true;
+    async function restore() {
+      if (!enableCache) {
+        return;
+      }
+      const snapshot = await loadCache(cacheKey);
+      if (!mounted || !snapshot) {
+        return;
+      }
+      if (snapshot.messages.length > 0 && messagesRef.current.length === 0) {
+        setMessages(snapshot.messages);
+      }
+      if (typeof snapshot.input === "string" && !inputRef.current) {
+        setInput(snapshot.input);
+      }
+    }
+    void restore();
+    return () => {
+      mounted = false;
+    };
+  }, [cacheKey, enableCache]);
+  react.useEffect(() => {
+    if (!enableCache) {
+      return;
+    }
+    void saveCache(cacheKey, {
+      messages,
+      input,
+      updatedAt: Date.now()
+    });
+  }, [cacheKey, enableCache, messages, input]);
+  react.useEffect(() => {
+    return () => {
+      abortRef.current?.abort();
+    };
+  }, []);
+  const flushPartial = react.useCallback((value) => {
+    partialRef.current = value;
+    if (streamFlushScheduledRef.current) {
+      return;
+    }
+    streamFlushScheduledRef.current = true;
+    requestAnimationFrame(() => {
+      streamFlushScheduledRef.current = false;
+      const assistantId = assistantIdRef.current;
+      if (!assistantId) {
+        return;
+      }
+      setMessages(
+        (current) => current.map(
+          (message) => message.id === assistantId ? { ...message, content: partialRef.current, status: "streaming" } : message
+        )
+      );
+    });
+  }, []);
+  const stopGenerating = react.useCallback(() => {
+    abortRef.current?.abort();
+    abortRef.current = null;
+    loadingRef.current = false;
+    setIsLoading(false);
+  }, []);
+  const sendMessage = react.useCallback(
+    async (messageText) => {
+      const text = trimContent(messageText ?? inputRef.current);
+      if (!text || loadingRef.current) {
+        return null;
+      }
+      const userMessage = {
+        id: createId("user"),
+        role: "user",
+        content: text,
+        createdAt: Date.now(),
+        status: "sent"
+      };
+      const assistantMessage = {
+        id: createId("assistant"),
+        role: "assistant",
+        content: "",
+        createdAt: Date.now(),
+        status: "streaming"
+      };
+      assistantIdRef.current = assistantMessage.id;
+      partialRef.current = "";
+      loadingRef.current = true;
+      setError(null);
+      setInput("");
+      setIsLoading(true);
+      setMessages((current) => [
+        ...current,
+        userMessage,
+        assistantMessage
+      ]);
+      const controller = new AbortController();
+      abortRef.current = controller;
+      try {
+        const conversation = [...messagesRef.current, userMessage];
+        const result = await providerInstance.streamMessage({
+          messages: conversation.map((message) => ({
+            role: message.role,
+            content: message.content
+          })),
+          signal: controller.signal,
+          timeoutMs,
+          onToken: (token) => {
+            flushPartial(`${partialRef.current}${token}`);
+          }
+        });
+        const content = result.content || partialRef.current;
+        setMessages((current) => {
+          const assistantId = assistantIdRef.current;
+          if (!assistantId) {
+            return current;
+          }
+          return current.map(
+            (message) => message.id === assistantId ? { ...message, content, status: "sent" } : message
+          );
+        });
+        const completedAssistantMessage = {
+          ...assistantMessage,
+          content,
+          status: "sent"
+        };
+        return completedAssistantMessage;
+      } catch (caughtError) {
+        const message = caughtError instanceof Error ? caughtError.message : "Failed to send message";
+        setError(message);
+        setMessages((current) => {
+          const assistantId = assistantIdRef.current;
+          if (!assistantId) {
+            return current;
+          }
+          return current.map(
+            (item) => item.id === assistantId ? {
+              ...item,
+              content: partialRef.current,
+              status: "error",
+              error: message
+            } : item
+          );
+        });
+        return null;
+      } finally {
+        loadingRef.current = false;
+        setIsLoading(false);
+        abortRef.current = null;
+        assistantIdRef.current = null;
+      }
+    },
+    [flushPartial, providerInstance, timeoutMs]
+  );
+  const clearMessages = react.useCallback(() => {
+    setMessages([]);
+    setError(null);
+    if (enableCache) {
+      void clearCache(cacheKey);
+    }
+  }, [cacheKey, enableCache]);
+  const retryLastMessage = react.useCallback(async () => {
+    const lastUserEntry = [...messagesRef.current].map((message, index) => ({ message, index })).reverse().find((entry) => entry.message.role === "user");
+    if (!lastUserEntry) {
+      return null;
+    }
+    const lastUserIndex = lastUserEntry.index;
+    const nextMessages = messagesRef.current.slice(0, lastUserIndex);
+    const content = lastUserEntry.message.content;
+    setMessages(nextMessages);
+    messagesRef.current = nextMessages;
+    return sendMessage(content);
+  }, [sendMessage]);
+  return {
+    messages,
+    input,
+    setInput,
+    sendMessage,
+    isLoading,
+    error,
+    stopGenerating,
+    clearMessages,
+    retryLastMessage
+  };
+}
+function useAIVoice(options = {}) {
+  const [transcript, setTranscript] = react.useState("");
+  const [isListening, setIsListening] = react.useState(false);
+  const [recordingUri, setRecordingUri] = react.useState(null);
+  const [error, setError] = react.useState(null);
+  const recognitionRef = react.useRef(null);
+  const recordingRef = react.useRef(null);
+  const cleanupRef = react.useRef(null);
+  const clearTranscript = react.useCallback(() => {
+    setTranscript("");
+    setError(null);
+  }, []);
+  const speak = react.useCallback(
+    async (text) => {
+      if (!text.trim()) {
+        return;
+      }
+      try {
+        const speechModule = await import('expo-speech').catch(() => null);
+        const speech = speechModule?.default ?? speechModule;
+        if (speech?.speak) {
+          speech.speak(text, {
+            rate: options.speechRate ?? 1,
+            pitch: options.speechPitch ?? 1
+          });
+          return;
+        }
+        if (typeof globalThis !== "undefined" && "speechSynthesis" in globalThis) {
+          const utterance = new SpeechSynthesisUtterance(text);
+          utterance.rate = options.speechRate ?? 1;
+          utterance.pitch = options.speechPitch ?? 1;
+          globalThis.speechSynthesis.speak(utterance);
+        }
+      } catch (caughtError) {
+        setError(
+          caughtError instanceof Error ? caughtError.message : "Failed to speak text"
+        );
+      }
+    },
+    [options.speechPitch, options.speechRate]
+  );
+  const stopListening = react.useCallback(async () => {
+    const recognition = recognitionRef.current;
+    if (recognition) {
+      recognition.stop?.();
+      recognitionRef.current = null;
+      cleanupRef.current?.();
+      cleanupRef.current = null;
+      setIsListening(false);
+      return;
+    }
+    const recording = recordingRef.current;
+    if (recording) {
+      try {
+        await recording.stopAndUnloadAsync();
+        setRecordingUri(recording.getURI?.() ?? null);
+      } catch (caughtError) {
+        setError(
+          caughtError instanceof Error ? caughtError.message : "Failed to stop recording"
+        );
+      } finally {
+        recordingRef.current = null;
+        setIsListening(false);
+      }
+    }
+  }, []);
+  const startListening = react.useCallback(async () => {
+    setError(null);
+    clearTranscript();
+    const SpeechRecognition = globalThis.SpeechRecognition ?? globalThis.webkitSpeechRecognition ?? null;
+    if (SpeechRecognition) {
+      const recognition = new SpeechRecognition();
+      recognition.lang = options.language ?? "en-US";
+      recognition.continuous = options.continuous ?? false;
+      recognition.interimResults = options.interimResults ?? true;
+      recognition.maxAlternatives = 1;
+      recognition.onresult = (event) => {
+        let nextTranscript = "";
+        for (let index = 0; index < event.results.length; index += 1) {
+          const result = event.results[index];
+          nextTranscript += result[0]?.transcript ?? "";
+        }
+        setTranscript(nextTranscript.trim());
+      };
+      recognition.onerror = (event) => {
+        setError(
+          event?.error ? String(event.error) : "Speech recognition failed"
+        );
+        setIsListening(false);
+      };
+      recognition.onend = () => {
+        setIsListening(false);
+        recognitionRef.current = null;
+      };
+      recognitionRef.current = recognition;
+      recognition.start();
+      setIsListening(true);
+      return;
+    }
+    try {
+      const expoAv = await import('expo-av').catch(() => null);
+      const Audio = expoAv?.Audio ?? null;
+      if (!Audio) {
+        throw new Error("Speech recognition is unavailable on this platform");
+      }
+      const permission = await Audio.requestPermissionsAsync();
+      if (!permission.granted) {
+        throw new Error("Microphone permission is required");
+      }
+      await Audio.setAudioModeAsync({
+        allowsRecordingIOS: true,
+        playsInSilentModeIOS: true,
+        shouldDuckAndroid: true,
+        staysActiveInBackground: false
+      });
+      const recording = new Audio.Recording();
+      await recording.prepareToRecordAsync(
+        Audio.RecordingOptionsPresets.HIGH_QUALITY
+      );
+      await recording.startAsync();
+      recordingRef.current = recording;
+      setIsListening(true);
+      setError(
+        "Speech recognition is not available in Expo Go. Audio recording started instead."
+      );
+    } catch (caughtError) {
+      setError(
+        caughtError instanceof Error ? caughtError.message : "Failed to start listening"
+      );
+      setIsListening(false);
+    }
+  }, [
+    clearTranscript,
+    options.continuous,
+    options.interimResults,
+    options.language
+  ]);
+  react.useEffect(() => {
+    return () => {
+      recognitionRef.current?.stop?.();
+      cleanupRef.current?.();
+      const recording = recordingRef.current;
+      if (recording) {
+        void recording.stopAndUnloadAsync().catch(() => void 0);
+      }
+    };
+  }, []);
+  return {
+    startListening,
+    stopListening,
+    transcript,
+    isListening,
+    recordingUri,
+    error,
+    speak,
+    clearTranscript
+  };
+}
+var defaultTheme = {
+  surfaceColor: "#111827",
+  textColor: "#f9fafb",
+  textMutedColor: "#94a3b8",
+  borderColor: "#334155",
+  primaryColor: "#38bdf8"
+};
+function AIInput({
+  value,
+  onChangeText,
+  onSend,
+  placeholder = "Type a message",
+  disabled,
+  loading,
+  className,
+  style,
+  inputStyle,
+  buttonStyle,
+  buttonTextStyle,
+  multiline = true,
+  showSendIcon = true,
+  sendLabel = "Send"
+}) {
+  const isDisabled = disabled || loading || value.trim().length === 0;
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { ...{ className }, style: [styles.container, style, { borderColor: defaultTheme.borderColor, backgroundColor: defaultTheme.surfaceColor }], children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      reactNative.TextInput,
+      {
+        value,
+        onChangeText,
+        placeholder,
+        placeholderTextColor: defaultTheme.textMutedColor,
+        editable: !disabled,
+        multiline,
+        style: [styles.input, { color: defaultTheme.textColor }, inputStyle]
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      reactNative.Pressable,
+      {
+        accessibilityRole: "button",
+        onPress: () => {
+          if (!isDisabled) {
+            void onSend();
+          }
+        },
+        style: ({ pressed }) => [
+          styles.button,
+          {
+            opacity: isDisabled ? 0.5 : pressed ? 0.85 : 1,
+            backgroundColor: defaultTheme.primaryColor
+          },
+          buttonStyle
+        ],
+        children: loading ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.ActivityIndicator, { color: "#ffffff" }) : /* @__PURE__ */ jsxRuntime.jsxs(reactNative.Text, { style: [styles.buttonText, buttonTextStyle], children: [
+          showSendIcon ? "\u27A4 " : "",
+          sendLabel
+        ] })
+      }
+    )
+  ] });
+}
+var styles = reactNative.StyleSheet.create({
+  container: {
+    borderRadius: 20,
+    borderWidth: reactNative.StyleSheet.hairlineWidth,
+    flexDirection: "row",
+    gap: 10,
+    padding: 12,
+    alignItems: "flex-end"
+  },
+  input: {
+    flex: 1,
+    minHeight: 44,
+    maxHeight: 140,
+    fontSize: 15,
+    paddingVertical: 8
+  },
+  button: {
+    alignItems: "center",
+    borderRadius: 14,
+    minHeight: 42,
+    justifyContent: "center",
+    paddingHorizontal: 16,
+    paddingVertical: 10
+  },
+  buttonText: {
+    color: "#ffffff",
+    fontSize: 14,
+    fontWeight: "700"
+  }
+});
+function parseInline(content) {
+  const parts = [];
+  let cursor = 0;
+  const pattern = /\[([^\]]+)\]\(([^)]+)\)|`([^`]+)`|\*\*([^*]+)\*\*/g;
+  for (; ; ) {
+    const match = pattern.exec(content);
+    if (!match) {
+      break;
+    }
+    if (match.index > cursor) {
+      parts.push({ kind: "text", value: content.slice(cursor, match.index) });
+    }
+    if (match[1] && match[2]) {
+      parts.push({ kind: "link", value: match[1], url: match[2] });
+    } else if (match[3]) {
+      parts.push({ kind: "code", value: match[3] });
+    } else if (match[4]) {
+      parts.push({ kind: "bold", value: match[4] });
+    }
+    cursor = pattern.lastIndex;
+  }
+  if (cursor < content.length) {
+    parts.push({ kind: "text", value: content.slice(cursor) });
+  }
+  return parts;
+}
+function renderInlineParts(parts, onLinkPress) {
+  return parts.map((part, index) => {
+    if (part.kind === "text") {
+      return part.value;
+    }
+    if (part.kind === "code") {
+      return /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles2.inlineCode, children: part.value }, `code-${index}`);
+    }
+    if (part.kind === "bold") {
+      return /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles2.bold, children: part.value }, `bold-${index}`);
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      reactNative.Text,
+      {
+        style: styles2.link,
+        onPress: () => {
+          if (onLinkPress) {
+            onLinkPress(part.url);
+            return;
+          }
+          reactNative.Linking.openURL(part.url).catch(() => void 0);
+        },
+        children: part.value
+      },
+      `link-${index}`
+    );
+  });
+}
+function splitMarkdownBlocks(content) {
+  const blocks = [];
+  const regex = /```([a-zA-Z0-9_-]+)?\n([\s\S]*?)```/g;
+  let cursor = 0;
+  for (; ; ) {
+    const match = regex.exec(content);
+    if (!match) {
+      break;
+    }
+    if (match.index > cursor) {
+      blocks.push({ type: "text", value: content.slice(cursor, match.index) });
+    }
+    blocks.push({ type: "code", value: match[2], language: match[1] });
+    cursor = regex.lastIndex;
+  }
+  if (cursor < content.length) {
+    blocks.push({ type: "text", value: content.slice(cursor) });
+  }
+  return blocks;
+}
+function MarkdownText({ content, textStyle, codeStyle, onLinkPress, selectable = true }) {
+  const blocks = react.useMemo(() => splitMarkdownBlocks(content), [content]);
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { children: blocks.map((block, blockIndex) => {
+    if (block.type === "code") {
+      return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles2.codeBlock, children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { selectable, style: [styles2.codeText, codeStyle], children: block.value.trimEnd() }) }, `codeblock-${blockIndex}`);
+    }
+    const paragraphs = block.value.split(/\n{2,}/).filter(Boolean);
+    return paragraphs.map((paragraph, paragraphIndex) => /* @__PURE__ */ jsxRuntime.jsxs(
+      reactNative.Text,
+      {
+        selectable,
+        style: textStyle,
+        children: [
+          renderInlineParts(parseInline(paragraph), onLinkPress),
+          paragraphIndex < paragraphs.length - 1 ? "\n\n" : ""
+        ]
+      },
+      `text-${blockIndex}-${paragraphIndex}`
+    ));
+  }) });
+}
+var styles2 = reactNative.StyleSheet.create({
+  codeBlock: {
+    borderRadius: 14,
+    marginTop: 10,
+    marginBottom: 10,
+    overflow: "hidden"
+  },
+  codeText: {
+    backgroundColor: "#111827",
+    color: "#f9fafb",
+    fontFamily: "Courier",
+    fontSize: 13,
+    lineHeight: 18,
+    padding: 12
+  },
+  inlineCode: {
+    backgroundColor: "#374151",
+    borderRadius: 6,
+    color: "#f9fafb",
+    fontFamily: "Courier",
+    fontSize: 13,
+    paddingHorizontal: 4,
+    paddingVertical: 1
+  },
+  bold: {
+    fontWeight: "700"
+  },
+  link: {
+    color: "#2563eb",
+    textDecorationLine: "underline"
+  }
+});
+var defaultTheme2 = {
+  backgroundColor: "#0b1020",
+  surfaceColor: "#111827",
+  surfaceMutedColor: "#1f2937",
+  textColor: "#f9fafb",
+  textMutedColor: "#cbd5e1",
+  borderColor: "#334155",
+  primaryColor: "#38bdf8",
+  userBubbleColor: "#1d4ed8",
+  assistantBubbleColor: "#111827",
+  codeBackgroundColor: "#0f172a",
+  codeTextColor: "#e2e8f0",
+  errorColor: "#ef4444"
+};
+function AIMessageBubble({
+  message,
+  theme,
+  className,
+  style,
+  contentStyle,
+  codeStyle,
+  onLinkPress,
+  showTimestamp
+}) {
+  const colors = { ...defaultTheme2, ...theme };
+  const isUser = message.role === "user";
+  const bubbleColor = isUser ? colors.userBubbleColor : colors.assistantBubbleColor;
+  const alignSelf = isUser ? "flex-end" : "flex-start";
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { ...{ className }, style: [styles3.wrapper, { alignSelf }, style], children: /* @__PURE__ */ jsxRuntime.jsxs(
+    reactNative.View,
+    {
+      style: [
+        styles3.bubble,
+        {
+          backgroundColor: bubbleColor,
+          borderColor: colors.borderColor
+        }
+      ],
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          MarkdownText,
+          {
+            content: message.content || (message.status === "streaming" ? " " : ""),
+            textStyle: [styles3.content, { color: colors.textColor }, contentStyle],
+            codeStyle: [{ color: colors.codeTextColor }, codeStyle],
+            onLinkPress
+          }
+        ),
+        message.status === "streaming" || message.status === "sending" ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [styles3.status, { color: colors.textMutedColor }], children: "Generating..." }) : null,
+        message.status === "error" && message.error ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [styles3.status, { color: colors.errorColor }], children: message.error }) : null,
+        showTimestamp ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [styles3.timestamp, { color: colors.textMutedColor }], children: new Date(message.createdAt).toLocaleTimeString() }) : null
+      ]
+    }
+  ) });
+}
+var styles3 = reactNative.StyleSheet.create({
+  wrapper: {
+    marginVertical: 6,
+    maxWidth: "90%"
+  },
+  bubble: {
+    borderRadius: 18,
+    borderWidth: reactNative.StyleSheet.hairlineWidth,
+    paddingHorizontal: 14,
+    paddingVertical: 12,
+    shadowColor: "#000",
+    shadowOpacity: 0.08,
+    shadowRadius: 8,
+    shadowOffset: {
+      width: 0,
+      height: 2
+    },
+    elevation: 1
+  },
+  content: {
+    fontSize: 15,
+    lineHeight: 21
+  },
+  status: {
+    fontSize: 12,
+    marginTop: 8,
+    opacity: 0.85
+  },
+  timestamp: {
+    fontSize: 11,
+    marginTop: 6,
+    opacity: 0.65,
+    textAlign: "right"
+  }
+});
+function AITypingIndicator({ color = "#38bdf8", style }) {
+  const dotOne = react.useRef(new reactNative.Animated.Value(0)).current;
+  const dotTwo = react.useRef(new reactNative.Animated.Value(0)).current;
+  const dotThree = react.useRef(new reactNative.Animated.Value(0)).current;
+  const animValues = react.useMemo(() => [dotOne, dotTwo, dotThree], [dotOne, dotTwo, dotThree]);
+  react.useEffect(() => {
+    const animations = animValues.map(
+      (value, index) => reactNative.Animated.loop(
+        reactNative.Animated.sequence([
+          reactNative.Animated.delay(index * 140),
+          reactNative.Animated.timing(value, { toValue: 1, duration: 420, useNativeDriver: true }),
+          reactNative.Animated.timing(value, { toValue: 0, duration: 420, useNativeDriver: true })
+        ])
+      )
+    );
+    animations.forEach((animation) => animation.start());
+    return () => {
+      animations.forEach((animation) => animation.stop());
+    };
+  }, [animValues]);
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [styles4.container, style], children: animValues.map((value, index) => /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.Animated.View,
+    {
+      style: [
+        styles4.dot,
+        {
+          backgroundColor: color,
+          opacity: value.interpolate({ inputRange: [0, 1], outputRange: [0.35, 1] }),
+          transform: [
+            {
+              translateY: value.interpolate({ inputRange: [0, 1], outputRange: [0, -4] })
+            }
+          ]
+        }
+      ]
+    },
+    index
+  )) });
+}
+var styles4 = reactNative.StyleSheet.create({
+  container: {
+    flexDirection: "row",
+    gap: 6,
+    paddingVertical: 6,
+    alignItems: "center"
+  },
+  dot: {
+    borderRadius: 999,
+    height: 8,
+    width: 8
+  }
+});
+var defaultTheme3 = {
+  backgroundColor: "#020617",
+  surfaceColor: "#0f172a",
+  surfaceMutedColor: "#1e293b",
+  textColor: "#f8fafc",
+  textMutedColor: "#94a3b8",
+  borderColor: "#334155",
+  primaryColor: "#38bdf8",
+  userBubbleColor: "#1d4ed8",
+  assistantBubbleColor: "#111827",
+  codeBackgroundColor: "#0f172a",
+  codeTextColor: "#e2e8f0",
+  errorColor: "#f87171"
+};
+function AIChatView({
+  messages,
+  input,
+  setInput,
+  sendMessage,
+  isLoading,
+  error,
+  title = "AI Chat",
+  subtitle,
+  emptyStateTitle = "Start a conversation",
+  emptyStateDescription = "Send a message to begin chatting with the provider.",
+  className,
+  style,
+  contentContainerStyle,
+  headerStyle,
+  footerStyle,
+  theme,
+  renderMessage,
+  renderFooter,
+  renderHeader,
+  onPressRetry
+}) {
+  const colors = react.useMemo(() => ({ ...defaultTheme3, ...theme }), [theme]);
+  const listRef = react.useRef(null);
+  react.useEffect(() => {
+    requestAnimationFrame(() => {
+      listRef.current?.scrollToEnd({ animated: true });
+    });
+  }, [messages.length, isLoading]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    reactNative.KeyboardAvoidingView,
+    {
+      ...{ className },
+      behavior: reactNative.Platform.OS === "ios" ? "padding" : void 0,
+      style: [styles5.root, { backgroundColor: colors.backgroundColor }, style],
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: [styles5.header, headerStyle], children: [
+          renderHeader ? renderHeader() : /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [styles5.title, { color: colors.textColor }], children: title }),
+            subtitle ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [styles5.subtitle, { color: colors.textMutedColor }], children: subtitle }) : null
+          ] }),
+          onPressRetry ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Pressable, { onPress: onPressRetry, style: [styles5.retryButton, { borderColor: colors.borderColor }], children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [styles5.retryText, { color: colors.primaryColor }], children: "Retry" }) }) : null
+        ] }),
+        error ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [styles5.error, { color: colors.errorColor }], children: error }) : null,
+        /* @__PURE__ */ jsxRuntime.jsx(
+          reactNative.FlatList,
+          {
+            ref: listRef,
+            data: messages,
+            keyExtractor: (item) => item.id,
+            contentContainerStyle: [styles5.listContent, contentContainerStyle, messages.length === 0 ? styles5.emptyList : null],
+            renderItem: ({ item, index }) => /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: renderMessage ? renderMessage(item, index) : /* @__PURE__ */ jsxRuntime.jsx(AIMessageBubble, { message: item, theme }) }),
+            ListEmptyComponent: /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles5.emptyState, children: [
+              /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [styles5.emptyTitle, { color: colors.textColor }], children: emptyStateTitle }),
+              /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [styles5.emptyDescription, { color: colors.textMutedColor }], children: emptyStateDescription })
+            ] }),
+            ListFooterComponent: /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: footerStyle, children: [
+              isLoading ? /* @__PURE__ */ jsxRuntime.jsx(AITypingIndicator, { color: colors.primaryColor }) : null,
+              renderFooter ? renderFooter() : null
+            ] }),
+            keyboardShouldPersistTaps: "handled"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          AIInput,
+          {
+            value: input,
+            onChangeText: setInput,
+            onSend: () => {
+              void sendMessage();
+            },
+            loading: isLoading,
+            style: styles5.input
+          }
+        )
+      ]
+    }
+  );
+}
+var styles5 = reactNative.StyleSheet.create({
+  root: {
+    flex: 1,
+    padding: 16
+  },
+  header: {
+    flexDirection: "row",
+    alignItems: "flex-start",
+    justifyContent: "space-between",
+    marginBottom: 12
+  },
+  title: {
+    fontSize: 26,
+    fontWeight: "800"
+  },
+  subtitle: {
+    fontSize: 14,
+    marginTop: 4
+  },
+  retryButton: {
+    borderRadius: 999,
+    borderWidth: reactNative.StyleSheet.hairlineWidth,
+    paddingHorizontal: 14,
+    paddingVertical: 8
+  },
+  retryText: {
+    fontSize: 13,
+    fontWeight: "700"
+  },
+  error: {
+    fontSize: 13,
+    marginBottom: 8
+  },
+  listContent: {
+    flexGrow: 1,
+    paddingBottom: 16
+  },
+  emptyList: {
+    justifyContent: "center"
+  },
+  emptyState: {
+    alignItems: "center",
+    flex: 1,
+    justifyContent: "center",
+    paddingVertical: 48
+  },
+  emptyTitle: {
+    fontSize: 20,
+    fontWeight: "700"
+  },
+  emptyDescription: {
+    fontSize: 14,
+    marginTop: 8,
+    textAlign: "center"
+  },
+  input: {
+    marginTop: 12
+  }
+});
+
+exports.AIChatView = AIChatView;
+exports.AIInput = AIInput;
+exports.AIMessageBubble = AIMessageBubble;
+exports.AITypingIndicator = AITypingIndicator;
+exports.MarkdownText = MarkdownText;
+exports.buildDefaultCacheKey = buildDefaultCacheKey;
+exports.clamp = clamp;
+exports.clearCache = clearCache;
+exports.createGeminiProvider = createGeminiProvider;
+exports.createId = createId;
+exports.createLogger = createLogger;
+exports.createOpenAIProvider = createOpenAIProvider;
+exports.createProvider = createProvider;
+exports.isNonEmptyString = isNonEmptyString;
+exports.loadCache = loadCache;
+exports.mergeAssistantText = mergeAssistantText;
+exports.safeJsonParse = safeJsonParse;
+exports.saveCache = saveCache;
+exports.toConversationMessages = toConversationMessages;
+exports.toPlainText = toPlainText;
+exports.trimContent = trimContent;
+exports.useAIChat = useAIChat;
+exports.useAIVoice = useAIVoice;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map