react-native-ai-hooks 0.1.0 → 0.2.0

package/README.md

@@ -1,3 +1,8 @@
+[![npm downloads](https://img.shields.io/npm/dw/react-native-ai-hooks)](https://npmjs.com/package/react-native-ai-hooks)
+[![npm version](https://img.shields.io/npm/v/react-native-ai-hooks)](https://npmjs.com/package/react-native-ai-hooks)
+[![GitHub stars](https://img.shields.io/github/stars/nikapkh/react-native-ai-hooks)](https://github.com/nikapkh/react-native-ai-hooks)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
 # react-native-ai-hooks
 
 AI hooks for React Native — add Claude, OpenAI & Gemini to your app in minutes.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-ai-hooks",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "AI hooks for React Native — useAIChat, useAIStream, useImageAnalysis. Works with Claude, OpenAI & Gemini.",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/hooks/useAIVoice.ts

@@ -0,0 +1,219 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { PermissionsAndroid, Platform } from 'react-native';
+import Voice from '@react-native-voice/voice';
+
+interface UseAIVoiceOptions {
+	apiKey: string;
+	model?: string;
+	maxTokens?: number;
+	system?: string;
+	language?: string;
+	autoSendOnStop?: boolean;
+}
+
+interface UseAIVoiceReturn {
+	transcription: string;
+	response: string;
+	isRecording: boolean;
+	isLoading: boolean;
+	error: string | null;
+	startRecording: () => Promise<void>;
+	stopRecording: () => Promise<void>;
+	sendTranscription: (overrideText?: string) => Promise<string | null>;
+	clearVoiceState: () => void;
+}
+
+interface ClaudeTextBlock {
+	type?: string;
+	text?: string;
+}
+
+interface ClaudeApiResult {
+	content?: ClaudeTextBlock[];
+	error?: {
+		message?: string;
+	};
+}
+
+interface SpeechResultsEvent {
+	value?: string[];
+}
+
+interface SpeechErrorEvent {
+	error?: {
+		message?: string;
+	};
+}
+
+function getClaudeTextContent(data: unknown): string {
+	const content = (data as ClaudeApiResult)?.content;
+	if (!Array.isArray(content)) {
+		return '';
+	}
+
+	return content
+		.filter(item => item?.type === 'text' && typeof item.text === 'string')
+		.map(item => item.text as string)
+		.join('\n')
+		.trim();
+}
+
+export function useAIVoice(options: UseAIVoiceOptions): UseAIVoiceReturn {
+	const [transcription, setTranscription] = useState('');
+	const [response, setResponse] = useState('');
+	const [isRecording, setIsRecording] = useState(false);
+	const [isLoading, setIsLoading] = useState(false);
+	const [error, setError] = useState<string | null>(null);
+
+	const transcriptionRef = useRef('');
+	const isMountedRef = useRef(true);
+
+	const requestMicPermission = useCallback(async () => {
+		if (Platform.OS !== 'android') {
+			return true;
+		}
+
+		const permission = await PermissionsAndroid.request(
+			PermissionsAndroid.PERMISSIONS.RECORD_AUDIO,
+		);
+		return permission === PermissionsAndroid.RESULTS.GRANTED;
+	}, []);
+
+	const sendTranscription = useCallback(
+		async (overrideText?: string) => {
+			const prompt = (overrideText ?? transcriptionRef.current).trim();
+
+			if (!prompt) {
+				setError('No transcription available to send.');
+				return null;
+			}
+
+			if (!options.apiKey) {
+				setError('Missing Claude API key.');
+				return null;
+			}
+
+			setIsLoading(true);
+			setError(null);
+
+			try {
+				const apiResponse = await fetch('https://api.anthropic.com/v1/messages', {
+					method: 'POST',
+					headers: {
+						'Content-Type': 'application/json',
+						'x-api-key': options.apiKey,
+						'anthropic-version': '2023-06-01',
+					},
+					body: JSON.stringify({
+						model: options.model || 'claude-sonnet-4-20250514',
+						max_tokens: options.maxTokens ?? 1024,
+						system: options.system,
+						messages: [{ role: 'user', content: prompt }],
+					}),
+				});
+
+				const data = (await apiResponse.json()) as ClaudeApiResult;
+				if (!apiResponse.ok) {
+					throw new Error(data?.error?.message || `Claude API error: ${apiResponse.status}`);
+				}
+
+				const text = getClaudeTextContent(data);
+				if (!text) {
+					throw new Error('No text response returned by Claude API.');
+				}
+
+				setResponse(text);
+				return text;
+			} catch (err) {
+				const message = (err as Error).message || 'Failed to send transcription';
+				setError(message);
+				return null;
+			} finally {
+				if (isMountedRef.current) {
+					setIsLoading(false);
+				}
+			}
+		},
+		[options.apiKey, options.maxTokens, options.model, options.system],
+	);
+
+	const startRecording = useCallback(async () => {
+		setError(null);
+
+		const permissionGranted = await requestMicPermission();
+		if (!permissionGranted) {
+			setError('Microphone permission not granted.');
+			return;
+		}
+
+		try {
+			transcriptionRef.current = '';
+			setTranscription('');
+			await Voice.start(options.language || 'en-US');
+			setIsRecording(true);
+		} catch (err) {
+			const message = (err as Error).message || 'Failed to start voice recording';
+			setError(message);
+			setIsRecording(false);
+		}
+	}, [options.language, requestMicPermission]);
+
+	const stopRecording = useCallback(async () => {
+		try {
+			await Voice.stop();
+		} catch {
+			// Ignore stop failures; state is reset below.
+		} finally {
+			setIsRecording(false);
+		}
+
+		if (options.autoSendOnStop !== false) {
+			await sendTranscription();
+		}
+	}, [options.autoSendOnStop, sendTranscription]);
+
+	const clearVoiceState = useCallback(() => {
+		transcriptionRef.current = '';
+		setTranscription('');
+		setResponse('');
+		setError(null);
+	}, []);
+
+	useEffect(() => {
+		isMountedRef.current = true;
+
+		Voice.onSpeechResults = (event: SpeechResultsEvent) => {
+			const latestText = event?.value?.[0]?.trim() || '';
+			transcriptionRef.current = latestText;
+			setTranscription(latestText);
+		};
+
+		Voice.onSpeechError = (event: SpeechErrorEvent) => {
+			const message = event?.error?.message || 'Speech recognition failed.';
+			setError(message);
+			setIsRecording(false);
+		};
+
+		Voice.onSpeechEnd = () => {
+			setIsRecording(false);
+		};
+
+		return () => {
+			isMountedRef.current = false;
+			Voice.destroy().catch(() => undefined);
+			Voice.removeAllListeners();
+		};
+	}, []);
+
+	return {
+		transcription,
+		response,
+		isRecording,
+		isLoading,
+		error,
+		startRecording,
+		stopRecording,
+		sendTranscription,
+		clearVoiceState,
+	};
+}

package/src/index.ts

@@ -1,4 +1,5 @@
 export { useAIChat } from './hooks/useAIChat';
 export { useAIStream } from './hooks/useAIStream';
 export { useImageAnalysis } from './hooks/useImageAnalysis';
-export { useAIForm } from './hooks/useAIForm';
+export { useAIForm } from './hooks/useAIForm';
+export { useAIVoice } from './hooks/useAIVoice';