react-native-ai-hooks 0.2.0 → 0.4.0

package/src/types/index.ts

@@ -1,15 +1,189 @@
+/**
+ * Core Message Types
+ */
 export interface Message {
   role: 'user' | 'assistant';
   content: string;
+  timestamp?: number;
 }
 
-export interface AIProvider {
+/**
+ * AI Provider Types
+ */
+export type AIProviderType = 'anthropic' | 'openai' | 'gemini';
+
+export interface ProviderConfig {
+  provider: AIProviderType;
   apiKey: string;
-  provider?: 'claude' | 'openai' | 'gemini';
-  model?: string;
+  model: string;
+  baseUrl?: string;
+  timeout?: number;
+  maxRetries?: number;
 }
 
+/**
+ * Standardized API Response
+ */
 export interface AIResponse {
-  content: string;
+  text: string;
+  raw: Record<string, unknown>;
+  usage?: {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+  };
   error?: string;
+}
+
+/**
+ * API Request Options
+ */
+export interface AIRequestOptions {
+  system?: string;
+  temperature?: number;
+  maxTokens?: number;
+  topP?: number;
+  stopSequences?: string[];
+}
+
+/**
+ * Hook Options Interface
+ */
+export interface UseAIChatOptions {
+  apiKey: string;
+  provider?: AIProviderType;
+  model?: string;
+  system?: string;
+  temperature?: number;
+  maxTokens?: number;
+  baseUrl?: string;
+  timeout?: number;
+  maxRetries?: number;
+}
+
+export interface UseAIStreamOptions extends UseAIChatOptions {}
+
+export interface UseAIFormOptions {
+  apiKey: string;
+  provider?: AIProviderType;
+  model?: string;
+  system?: string;
+  temperature?: number;
+  maxTokens?: number;
+  baseUrl?: string;
+  timeout?: number;
+  maxRetries?: number;
+}
+
+export interface UseImageAnalysisOptions {
+  apiKey: string;
+  provider?: AIProviderType;
+  model?: string;
+  system?: string;
+  maxTokens?: number;
+  baseUrl?: string;
+  timeout?: number;
+  maxRetries?: number;
+  uriToBase64?: (uri: string) => Promise<string>;
+}
+
+/**
+ * Normalized Internal API Structures
+ */
+export interface NormalizedMessage {
+  role: 'user' | 'assistant';
+  content: NormalizedContent;
+}
+
+export type NormalizedContent =
+  | { type: 'text'; text: string }
+  | { type: 'image'; source: { type: 'base64'; media_type: string; data: string } }
+  | Array<NormalizedContent>;
+
+/**
+ * Provider-Specific Raw Responses
+ */
+export interface AnthropicResponse {
+  content?: Array<{ type: string; text?: string }>;
+  error?: { type: string; message?: string };
+  usage?: {
+    input_tokens?: number;
+    output_tokens?: number;
+  };
+}
+
+export interface OpenAIResponse {
+  choices?: Array<{ message?: { content?: string } }>;
+  error?: { message?: string };
+  usage?: {
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    total_tokens?: number;
+  };
+}
+
+export interface GeminiResponse {
+  candidates?: Array<{
+    content?: {
+      parts?: Array<{ text?: string }>;
+    };
+  }>;
+  error?: { message?: string };
+  usageMetadata?: {
+    promptTokenCount?: number;
+    candidatesTokenCount?: number;
+    totalTokenCount?: number;
+  };
+}
+
+/**
+ * Form Validation Input/Output
+ */
+export interface FormValidationRequest {
+  formData: Record<string, unknown>;
+  validationSchema?: Record<string, string>;
+  customInstructions?: string;
+}
+
+export interface FormValidationResult {
+  isValid: boolean;
+  errors: Record<string, string>;
+  raw: unknown;
+}
+
+/**
+ * Generic Hook Return Types
+ */
+export interface UseAIChatReturn {
+  messages: Message[];
+  isLoading: boolean;
+  error: string | null;
+  sendMessage: (content: string) => Promise<void>;
+  abort: () => void;
+  clearMessages: () => void;
+}
+
+export interface UseAIStreamReturn {
+  response: string;
+  isLoading: boolean;
+  error: string | null;
+  streamResponse: (prompt: string) => Promise<void>;
+  abort: () => void;
+  clearResponse: () => void;
+}
+
+export interface UseImageAnalysisReturn {
+  description: string;
+  isLoading: boolean;
+  error: string | null;
+  analyzeImage: (uri: string, prompt?: string) => Promise<string | null>;
+  clearDescription: () => void;
+}
+
+export interface UseAIFormReturn {
+  validationResult: FormValidationResult | null;
+  isLoading: boolean;
+  error: string | null;
+  validateForm: (input: FormValidationRequest) => Promise<FormValidationResult | null>;
+  clearValidation: () => void;
 }

package/src/utils/fetchWithRetry.ts

@@ -0,0 +1,98 @@
+/**
+ * Fetch with exponential backoff, timeout, and rate-limit handling
+ */
+
+interface FetchWithRetryOptions {
+  maxRetries?: number;
+  baseDelay?: number;
+  maxDelay?: number;
+  timeout?: number;
+  backoffMultiplier?: number;
+}
+
+interface RetryableError extends Error {
+  statusCode?: number;
+  isRetryable?: boolean;
+}
+
+export async function fetchWithRetry(
+  url: string,
+  init?: RequestInit,
+  options?: FetchWithRetryOptions,
+): Promise<Response> {
+  const {
+    maxRetries = 3,
+    baseDelay = 1000,
+    maxDelay = 10000,
+    timeout = 30000,
+    backoffMultiplier = 2,
+  } = options || {};
+
+  let lastError: RetryableError | undefined;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+      try {
+        const response = await fetch(url, {
+          ...init,
+          signal: controller.signal,
+        });
+
+        clearTimeout(timeoutId);
+
+        // Handle rate limiting
+        if (response.status === 429) {
+          const retryAfter = response.headers.get('Retry-After');
+          const delay = retryAfter ? parseInt(retryAfter, 10) * 1000 : Math.min(baseDelay * Math.pow(backoffMultiplier, attempt), maxDelay);
+
+          if (attempt < maxRetries) {
+            await new Promise(resolve => setTimeout(resolve, delay));
+            continue;
+          }
+        }
+
+        // Handle server errors (5xx) with retry
+        if (response.status >= 500 && attempt < maxRetries) {
+          const delay = Math.min(baseDelay * Math.pow(backoffMultiplier, attempt), maxDelay);
+          await new Promise(resolve => setTimeout(resolve, delay));
+          continue;
+        }
+
+        return response;
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    } catch (err) {
+      const error = err as RetryableError;
+
+      // Handle timeout
+      if (error.name === 'AbortError') {
+        error.isRetryable = attempt < maxRetries;
+
+        if (attempt < maxRetries) {
+          const delay = Math.min(baseDelay * Math.pow(backoffMultiplier, attempt), maxDelay);
+          await new Promise(resolve => setTimeout(resolve, delay));
+          continue;
+        }
+      }
+
+      lastError = error;
+
+      // Non-retryable errors should throw immediately
+      if (!error.isRetryable && attempt < maxRetries) {
+        const delay = Math.min(baseDelay * Math.pow(backoffMultiplier, attempt), maxDelay);
+        await new Promise(resolve => setTimeout(resolve, delay));
+        continue;
+      }
+
+      if (attempt === maxRetries) {
+        throw error;
+      }
+    }
+  }
+
+  throw lastError || new Error('Fetch failed after retries');
+}

package/src/utils/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Public utility exports for advanced use cases
+ */
+
+export { createProvider, ProviderFactory } from './providerFactory';
+export { fetchWithRetry } from './fetchWithRetry';
+
+export type { ProviderConfig, AIResponse, AIRequestOptions } from '../types';

package/src/utils/providerFactory.ts

@@ -0,0 +1,265 @@
+/**
+ * Unified Provider Factory for handling multiple AI providers
+ * Normalizes responses across Anthropic, OpenAI, and Gemini
+ */
+
+import type {
+  AIResponse,
+  AIRequestOptions,
+  AnthropicResponse,
+  OpenAIResponse,
+  GeminiResponse,
+  ProviderConfig,
+} from '../types';
+import { fetchWithRetry } from './fetchWithRetry';
+
+interface ProviderFactoryOptions extends ProviderConfig {
+  system?: string;
+  context?: Array<{ role: 'user' | 'assistant'; content: string }>;
+}
+
+interface ProviderRequest {
+  prompt: string;
+  options?: AIRequestOptions;
+  context?: Array<{ role: 'user' | 'assistant'; content: string }>;
+}
+
+export class ProviderFactory {
+  private config: ProviderConfig;
+
+  constructor(config: ProviderConfig) {
+    this.config = {
+      ...config,
+      timeout: config.timeout || 30000,
+      maxRetries: config.maxRetries || 3,
+    };
+  }
+
+  private getBaseUrl(): string {
+    if (this.config.baseUrl) {
+      return this.config.baseUrl;
+    }
+
+    switch (this.config.provider) {
+      case 'anthropic':
+        return 'https://api.anthropic.com';
+      case 'openai':
+        return 'https://api.openai.com';
+      case 'gemini':
+        return 'https://generativelanguage.googleapis.com';
+      default:
+        throw new Error(`Unknown provider: ${this.config.provider}`);
+    }
+  }
+
+  async makeRequest(request: ProviderRequest): Promise<AIResponse> {
+    switch (this.config.provider) {
+      case 'anthropic':
+        return this.makeAnthropicRequest(request);
+      case 'openai':
+        return this.makeOpenAIRequest(request);
+      case 'gemini':
+        return this.makeGeminiRequest(request);
+      default:
+        throw new Error(`Unknown provider: ${this.config.provider}`);
+    }
+  }
+
+  private async makeAnthropicRequest(request: ProviderRequest): Promise<AIResponse> {
+    const baseUrl = this.getBaseUrl();
+    const url = `${baseUrl}/v1/messages`;
+
+    const body = {
+      model: this.config.model,
+      max_tokens: request.options?.maxTokens || 1024,
+      temperature: request.options?.temperature ?? 0.7,
+      system: request.options?.system,
+      messages: this.buildAnthropicMessages(request),
+    };
+
+    const response = await fetchWithRetry(
+      url,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-api-key': this.config.apiKey,
+          'anthropic-version': '2023-06-01',
+        },
+        body: JSON.stringify(body),
+      },
+      {
+        timeout: this.config.timeout,
+        maxRetries: this.config.maxRetries,
+      },
+    );
+
+    const data = (await response.json()) as AnthropicResponse;
+
+    if (!response.ok) {
+      throw new Error(data?.error?.message || `Anthropic API error: ${response.status}`);
+    }
+
+    return this.normalizeAnthropicResponse(data);
+  }
+
+  private async makeOpenAIRequest(request: ProviderRequest): Promise<AIResponse> {
+    const baseUrl = this.getBaseUrl();
+    const url = `${baseUrl}/v1/chat/completions`;
+
+    const body = {
+      model: this.config.model,
+      max_tokens: request.options?.maxTokens || 1024,
+      temperature: request.options?.temperature ?? 0.7,
+      system: request.options?.system,
+      messages: this.buildOpenAIMessages(request),
+    };
+
+    const response = await fetchWithRetry(
+      url,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${this.config.apiKey}`,
+        },
+        body: JSON.stringify(body),
+      },
+      {
+        timeout: this.config.timeout,
+        maxRetries: this.config.maxRetries,
+      },
+    );
+
+    const data = (await response.json()) as OpenAIResponse;
+
+    if (!response.ok) {
+      throw new Error(data?.error?.message || `OpenAI API error: ${response.status}`);
+    }
+
+    return this.normalizeOpenAIResponse(data);
+  }
+
+  private async makeGeminiRequest(request: ProviderRequest): Promise<AIResponse> {
+    const baseUrl = this.getBaseUrl();
+    const url = `${baseUrl}/v1beta/models/${this.config.model}:generateContent?key=${this.config.apiKey}`;
+
+    const body = {
+      contents: this.buildGeminiMessages(request),
+      generationConfig: {
+        maxOutputTokens: request.options?.maxTokens || 1024,
+        temperature: request.options?.temperature ?? 0.7,
+      },
+    };
+
+    const response = await fetchWithRetry(
+      url,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+      },
+      {
+        timeout: this.config.timeout,
+        maxRetries: this.config.maxRetries,
+      },
+    );
+
+    const data = (await response.json()) as GeminiResponse;
+
+    if (!response.ok) {
+      throw new Error(data?.error?.message || `Gemini API error: ${response.status}`);
+    }
+
+    return this.normalizeGeminiResponse(data);
+  }
+
+  private buildAnthropicMessages(
+    request: ProviderRequest,
+  ): Array<{ role: 'user' | 'assistant'; content: string }> {
+    const messages = request.context || [];
+    return [...messages, { role: 'user', content: request.prompt }];
+  }
+
+  private buildOpenAIMessages(
+    request: ProviderRequest,
+  ): Array<{ role: 'user' | 'assistant'; content: string }> {
+    const messages = request.context || [];
+    return [...messages, { role: 'user', content: request.prompt }];
+  }
+
+  private buildGeminiMessages(request: ProviderRequest): Array<{ role: string; parts: Array<{ text: string }> }> {
+    const messages = request.context || [];
+
+    return messages
+      .map(msg => ({
+        role: msg.role === 'user' ? 'user' : 'model',
+        parts: [{ text: msg.content }],
+      }))
+      .concat({
+        role: 'user',
+        parts: [{ text: request.prompt }],
+      });
+  }
+
+  private normalizeAnthropicResponse(data: AnthropicResponse): AIResponse {
+    const textContent = data.content?.find(block => block.type === 'text');
+    const text = (textContent?.type === 'text' && 'text' in textContent ? (textContent as any).text : '') || '';
+
+    if (!text) {
+      throw new Error('No text content returned by Anthropic API');
+    }
+
+    return {
+      text,
+      raw: data,
+      usage: {
+        inputTokens: data.usage?.input_tokens,
+        outputTokens: data.usage?.output_tokens,
+        totalTokens: (data.usage?.input_tokens || 0) + (data.usage?.output_tokens || 0),
+      },
+    };
+  }
+
+  private normalizeOpenAIResponse(data: OpenAIResponse): AIResponse {
+    const text = data.choices?.[0]?.message?.content || '';
+
+    if (!text) {
+      throw new Error('No text content returned by OpenAI API');
+    }
+
+    return {
+      text,
+      raw: data,
+      usage: {
+        inputTokens: data.usage?.prompt_tokens,
+        outputTokens: data.usage?.completion_tokens,
+        totalTokens: data.usage?.total_tokens,
+      },
+    };
+  }
+
+  private normalizeGeminiResponse(data: GeminiResponse): AIResponse {
+    const text = data.candidates?.[0]?.content?.parts?.[0]?.text || '';
+
+    if (!text) {
+      throw new Error('No text content returned by Gemini API');
+    }
+
+    return {
+      text,
+      raw: data,
+      usage: {
+        inputTokens: data.usageMetadata?.promptTokenCount,
+        outputTokens: data.usageMetadata?.candidatesTokenCount,
+        totalTokens: data.usageMetadata?.totalTokenCount,
+      },
+    };
+  }
+}
+
+export function createProvider(config: ProviderConfig): ProviderFactory {
+  return new ProviderFactory(config);
+}