@umituz/react-native-ai-groq-provider 1.0.24 → 1.0.26

package/src/presentation/hooks/use-groq.hook.ts

@@ -3,10 +3,12 @@
  * Main React hook for Groq text generation
  */
 
-import { useState, useCallback, useMemo } from "react";
-import type { GroqGenerationConfig } from "../../domain/entities";
-import { generateText, generateStructured, streamText } from "../../application/use-cases";
-import { getUserFriendlyError } from "../../utils/error-mapper.util";
+import { useState, useCallback, useRef } from "react";
+import type { GroqGenerationConfig } from "../../domain/entities/groq.types";
+import { generateText } from "../../application/use-cases/text-generation.usecase";
+import { generateStructured } from "../../application/use-cases/structured-generation.usecase";
+import { streamText } from "../../application/use-cases/streaming.usecase";
+import { getUserFriendlyError } from "../../infrastructure/utils/error-mapper.util";
 
 export interface UseGroqOptions {
   model?: string;
@@ -39,24 +41,30 @@ export function useGroq(options: UseGroqOptions = {}): UseGroqReturn {
   const [error, setError] = useState<string | null>(null);
   const [result, setResult] = useState<string | null>(null);
 
-  const stableOptions = useMemo(
-    () => ({
-      model: options.model,
-      generationConfig: options.generationConfig,
-      onStart: options.onStart,
-      onSuccess: options.onSuccess,
-      onError: options.onError,
-    }),
-    [
-      options.model,
-      options.generationConfig?.temperature,
-      options.generationConfig?.maxTokens,
-      options.generationConfig?.topP,
-      options.onStart,
-      options.onSuccess,
-      options.onError,
-    ]
-  );
+  // Use refs to avoid unnecessary re-creates and JSON.stringify
+  const optionsRef = useRef(options);
+  const callbacksRef = useRef({
+    onStart: options.onStart,
+    onSuccess: options.onSuccess,
+    onError: options.onError,
+  });
+
+  // Update refs when options change
+  if (options.model !== optionsRef.current.model) {
+    optionsRef.current.model = options.model;
+  }
+  if (options.generationConfig !== optionsRef.current.generationConfig) {
+    optionsRef.current.generationConfig = options.generationConfig;
+  }
+  if (options.onStart !== callbacksRef.current.onStart) {
+    callbacksRef.current.onStart = options.onStart;
+  }
+  if (options.onSuccess !== callbacksRef.current.onSuccess) {
+    callbacksRef.current.onSuccess = options.onSuccess;
+  }
+  if (options.onError !== callbacksRef.current.onError) {
+    callbacksRef.current.onError = options.onError;
+  }
 
   const generate = useCallback(
     async (prompt: string, config?: GroqGenerationConfig): Promise<string> => {
@@ -64,27 +72,30 @@ export function useGroq(options: UseGroqOptions = {}): UseGroqReturn {
       setError(null);
       setResult(null);
 
-      stableOptions.onStart?.();
+      callbacksRef.current.onStart?.();
 
       try {
         const response = await generateText(prompt, {
-          model: stableOptions.model,
-          generationConfig: { ...stableOptions.generationConfig, ...config },
+          model: optionsRef.current.model,
+          generationConfig: {
+            ...optionsRef.current.generationConfig,
+            ...config,
+          },
         });
 
         setResult(response);
-        stableOptions.onSuccess?.(response);
+        callbacksRef.current.onSuccess?.(response);
         return response;
       } catch (err) {
         const errorMessage = getUserFriendlyError(err);
         setError(errorMessage);
-        stableOptions.onError?.(errorMessage);
+        callbacksRef.current.onError?.(errorMessage);
         throw err;
       } finally {
         setIsLoading(false);
       }
     },
-    [stableOptions]
+    [] // No deps - uses refs
   );
 
   const generateJSON = useCallback(
@@ -96,29 +107,32 @@ export function useGroq(options: UseGroqOptions = {}): UseGroqReturn {
       setError(null);
       setResult(null);
 
-      stableOptions.onStart?.();
+      callbacksRef.current.onStart?.();
 
       try {
         const response = await generateStructured<T>(prompt, {
-          model: stableOptions.model,
-          generationConfig: { ...stableOptions.generationConfig, ...config },
+          model: optionsRef.current.model,
+          generationConfig: {
+            ...optionsRef.current.generationConfig,
+            ...config,
+          },
           schema: config?.schema,
         });
 
         const jsonStr = JSON.stringify(response, null, 2);
         setResult(jsonStr);
-        stableOptions.onSuccess?.(jsonStr);
+        callbacksRef.current.onSuccess?.(jsonStr);
         return response;
       } catch (err) {
         const errorMessage = getUserFriendlyError(err);
         setError(errorMessage);
-        stableOptions.onError?.(errorMessage);
+        callbacksRef.current.onError?.(errorMessage);
         throw err;
       } finally {
         setIsLoading(false);
       }
     },
-    [stableOptions]
+    [] // No deps - uses refs
   );
 
   const stream = useCallback(
@@ -133,32 +147,35 @@ export function useGroq(options: UseGroqOptions = {}): UseGroqReturn {
 
       let fullContent = "";
 
-      stableOptions.onStart?.();
+      callbacksRef.current.onStart?.();
 
       try {
         for await (const chunk of streamText(prompt, {
-          model: stableOptions.model,
-          generationConfig: { ...stableOptions.generationConfig, ...config },
+          model: optionsRef.current.model,
+          generationConfig: {
+            ...optionsRef.current.generationConfig,
+            ...config,
+          },
           callbacks: { onChunk: (c) => {
             fullContent += c;
             onChunk(c);
           }},
         })) {
-          // Consume iterator
+          fullContent += chunk;
         }
 
         setResult(fullContent);
-        stableOptions.onSuccess?.(fullContent);
+        callbacksRef.current.onSuccess?.(fullContent);
       } catch (err) {
         const errorMessage = getUserFriendlyError(err);
         setError(errorMessage);
-        stableOptions.onError?.(errorMessage);
+        callbacksRef.current.onError?.(errorMessage);
         throw err;
       } finally {
         setIsLoading(false);
       }
     },
-    [stableOptions]
+    [] // No deps - uses refs
   );
 
   const reset = useCallback(() => {

package/src/providers/ConfigBuilder.ts

@@ -3,8 +3,8 @@
  * Builder pattern for Groq configuration
  */
 
-import type { GroqConfig, GroqGenerationConfig } from "../domain/entities";
-import { DEFAULT_MODELS } from "../domain/entities";
+import type { GroqConfig, GroqGenerationConfig } from "../domain/entities/groq.types";
+import { DEFAULT_MODELS } from "../domain/entities/groq.types";
 
 /**
  * Builder for Groq configuration
@@ -12,41 +12,26 @@ import { DEFAULT_MODELS } from "../domain/entities";
 export class ConfigBuilder {
   private config: Partial<GroqConfig> = {};
 
-  /**
-   * Set API key
-   */
   withApiKey(apiKey: string): ConfigBuilder {
     this.config.apiKey = apiKey;
     return this;
   }
 
-  /**
-   * Set base URL
-   */
   withBaseUrl(baseUrl: string): ConfigBuilder {
     this.config.baseUrl = baseUrl;
     return this;
   }
 
-  /**
-   * Set timeout
-   */
   withTimeout(timeoutMs: number): ConfigBuilder {
     this.config.timeoutMs = timeoutMs;
     return this;
   }
 
-  /**
-   * Set default text model
-   */
   withTextModel(model: string): ConfigBuilder {
     this.config.textModel = model;
     return this;
   }
 
-  /**
-   * Build configuration
-   */
   build(): GroqConfig {
     if (!this.config.apiKey) {
       throw new Error("API key is required. Use withApiKey() to set it.");
@@ -59,13 +44,6 @@ export class ConfigBuilder {
       textModel: this.config.textModel || DEFAULT_MODELS.TEXT,
     };
   }
-
-  /**
-   * Create a new builder instance
-   */
-  static create(): ConfigBuilder {
-    return new ConfigBuilder();
-  }
 }
 
 /**
@@ -74,86 +52,37 @@ export class ConfigBuilder {
 export class GenerationConfigBuilder {
   private config: GroqGenerationConfig = {};
 
-  /**
-   * Set temperature
-   */
   withTemperature(temperature: number): GenerationConfigBuilder {
     this.config.temperature = temperature;
     return this;
   }
 
-  /**
-   * Set max tokens
-   */
   withMaxTokens(maxTokens: number): GenerationConfigBuilder {
     this.config.maxTokens = maxTokens;
     return this;
   }
 
-  /**
-   * Set top P
-   */
   withTopP(topP: number): GenerationConfigBuilder {
     this.config.topP = topP;
     return this;
   }
 
-  /**
-   * Set frequency penalty
-   */
   withFrequencyPenalty(penalty: number): GenerationConfigBuilder {
     this.config.frequencyPenalty = penalty;
     return this;
   }
 
-  /**
-   * Set presence penalty
-   */
   withPresencePenalty(penalty: number): GenerationConfigBuilder {
     this.config.presencePenalty = penalty;
     return this;
   }
 
-  /**
-   * Set stop sequences
-   */
   withStop(stop: string[]): GenerationConfigBuilder {
     this.config.stop = stop;
     return this;
   }
 
-  /**
-   * Build configuration
-   */
   build(): GroqGenerationConfig {
     return { ...this.config };
   }
-
-  /**
-   * Create a new builder instance
-   */
-  static create(): GenerationConfigBuilder {
-    return new GenerationConfigBuilder();
-  }
-
-  /**
-   * Create a balanced configuration
-   */
-  static balanced(): GenerationConfigBuilder {
-    return new GenerationConfigBuilder().withTemperature(0.7);
-  }
-
-  /**
-   * Create a creative configuration
-   */
-  static creative(): GenerationConfigBuilder {
-    return new GenerationConfigBuilder().withTemperature(1.0);
-  }
-
-  /**
-   * Create a precise configuration
-   */
-  static precise(): GenerationConfigBuilder {
-    return new GenerationConfigBuilder().withTemperature(0.3);
-  }
 }

package/src/providers/ProviderFactory.ts

@@ -3,8 +3,7 @@
  * Factory for creating configured Groq provider instances
  */
 
-import { groqHttpClient } from "../infrastructure/services/GroqClient";
-import { ConfigBuilder, GenerationConfigBuilder } from "./ConfigBuilder";
+import { groqHttpClient } from "../infrastructure/http/groq-http-client";
 
 /**
  * Provider configuration options
@@ -16,14 +15,6 @@ export interface ProviderConfig {
   defaultModel?: string;
 }
 
-/**
- * Provider factory options
- */
-export interface ProviderFactoryOptions {
-  enableTelemetry?: boolean;
-  onError?: (error: Error) => void;
-}
-
 /**
  * Initialize Groq provider with configuration
  */
@@ -37,61 +28,15 @@ export function initializeProvider(config: ProviderConfig): void {
 }
 
 /**
- * Provider factory - creates configured provider instances
+ * Reset provider configuration
  */
-export const providerFactory = {
-  /**
-   * Create a new provider instance
-   */
-  create(config: ProviderConfig): void {
-    initializeProvider(config);
-  },
-
-  /**
-   * Create provider from environment variables
-   */
-  fromEnv(): void {
-    const apiKey = process.env.GROQ_API_KEY;
-
-    if (!apiKey) {
-      throw new Error("GROQ_API_KEY environment variable is not set");
-    }
-
-    initializeProvider({
-      apiKey,
-      baseUrl: process.env.GROQ_BASE_URL,
-      timeoutMs: process.env.GROQ_TIMEOUT_MS ? parseInt(process.env.GROQ_TIMEOUT_MS) : undefined,
-    });
-  },
-
-  /**
-   * Reset provider (clear configuration)
-   */
-  reset(): void {
-    groqHttpClient.reset();
-  },
-
-  /**
-   * Check if provider is initialized
-   */
-  isInitialized(): boolean {
-    return groqHttpClient.isInitialized();
-  },
-};
-
-/**
- * Convenience function to initialize provider
- */
-export function configureProvider(config: ProviderConfig): void {
-  providerFactory.create(config);
+export function resetProvider(): void {
+  groqHttpClient.reset();
 }
 
 /**
- * Convenience function to reset provider
+ * Check if provider is initialized
  */
-export function resetProvider(): void {
-  providerFactory.reset();
+export function isProviderInitialized(): boolean {
+  return groqHttpClient.isInitialized();
 }
-
-// Re-export builders
-export { ConfigBuilder, GenerationConfigBuilder };

package/src/shared/request-builder.ts

@@ -7,8 +7,8 @@ import type {
   GroqChatRequest,
   GroqGenerationConfig,
   GroqMessage,
-} from "../domain/entities";
-import { DEFAULT_MODELS } from "../domain/entities";
+} from "../domain/entities/groq.types";
+import { DEFAULT_MODELS } from "../domain/entities/groq.types";
 
 export interface RequestBuilderOptions {
   model?: string;
@@ -29,17 +29,36 @@ export class RequestBuilder {
       defaultMaxTokens = 1024,
     } = options;
 
-    return {
+    const request: GroqChatRequest = {
       model,
       messages,
-      temperature: generationConfig.temperature ?? defaultTemperature,
-      max_tokens: generationConfig.maxTokens ?? defaultMaxTokens,
-      top_p: generationConfig.topP,
-      n: generationConfig.n,
-      stop: generationConfig.stop,
-      frequency_penalty: generationConfig.frequencyPenalty,
-      presence_penalty: generationConfig.presencePenalty,
+      temperature: generationConfig.temperature !== undefined
+        ? generationConfig.temperature
+        : defaultTemperature,
+      max_tokens: generationConfig.maxTokens !== undefined
+        ? generationConfig.maxTokens
+        : defaultMaxTokens,
     };
+
+    // Only include defined optional properties
+    // Map camelCase to snake_case for API
+    if (generationConfig.topP !== undefined) {
+      request.top_p = generationConfig.topP;
+    }
+    if (generationConfig.n !== undefined) {
+      request.n = generationConfig.n;
+    }
+    if (generationConfig.stop !== undefined) {
+      request.stop = generationConfig.stop;
+    }
+    if (generationConfig.frequencyPenalty !== undefined) {
+      request.frequency_penalty = generationConfig.frequencyPenalty;
+    }
+    if (generationConfig.presencePenalty !== undefined) {
+      request.presence_penalty = generationConfig.presencePenalty;
+    }
+
+    return request;
   }
 
   static buildPromptRequest(

package/src/shared/response-handler.ts

@@ -0,0 +1,93 @@
+/**
+ * Response Handler Utility
+ * Handles API response parsing and extraction
+ */
+
+import type { GroqChatResponse, GroqUsage, GroqFinishReason } from "../domain/entities/groq.types";
+
+interface Logger {
+  debug: (tag: string, message: string, context?: Record<string, unknown>) => void;
+  isEnabled?: () => boolean;
+}
+
+export interface ResponseHandlerResult {
+  content: string;
+  usage: {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+  };
+  finishReason: GroqFinishReason;
+}
+
+export class ResponseHandler {
+  /**
+   * Extract content from chat completion response
+   */
+  static extractContent(response: GroqChatResponse): string {
+    const choices = response.choices;
+    if (!choices || choices.length === 0) {
+      return "";
+    }
+    return choices[0].message?.content || "";
+  }
+
+  /**
+   * Handle complete response and extract all relevant data
+   */
+  static handleResponse(response: GroqChatResponse): ResponseHandlerResult {
+    const choices = response.choices;
+
+    if (!choices || choices.length === 0) {
+      return {
+        content: "",
+        usage: this.extractUsage(response.usage),
+        finishReason: "stop",
+      };
+    }
+
+    const choice = choices[0];
+    return {
+      content: choice.message?.content || "",
+      usage: this.extractUsage(response.usage),
+      finishReason: choice.finish_reason || "stop",
+    };
+  }
+
+  /**
+   * Extract usage information
+   */
+  private static extractUsage(usage: GroqUsage): {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+  } {
+    return {
+      promptTokens: usage.prompt_tokens || 0,
+      completionTokens: usage.completion_tokens || 0,
+      totalTokens: usage.total_tokens || 0,
+    };
+  }
+
+  /**
+   * Log response details (only if logger is enabled)
+   */
+  static logResponse(logger: Logger, response: GroqChatResponse, apiMs: number): void {
+    // Early return if logging is disabled
+    if (logger.isEnabled && !logger.isEnabled()) {
+      return;
+    }
+
+    const choices = response.choices;
+    const firstChoice = choices?.[0];
+
+    logger.debug("ResponseHandler", "API response received", {
+      model: response.model,
+      promptTokens: response.usage.prompt_tokens,
+      completionTokens: response.usage.completion_tokens,
+      totalTokens: response.usage.total_tokens,
+      finishReason: firstChoice?.finish_reason,
+      apiDuration: `${apiMs}ms`,
+    });
+  }
+}

package/src/types/react-native-global.d.ts

@@ -0,0 +1,12 @@
+/**
+ * React Native Global Declarations
+ * Type definitions for React Native globals
+ */
+
+declare const __DEV__: boolean;
+
+declare global {
+  const __DEV__: boolean;
+}
+
+export {};

package/src/application/use-cases/index.ts

@@ -1,19 +0,0 @@
-/**
- * Application Layer - Use Cases
- * Business logic orchestrators
- */
-
-export { generateText } from "./text-generation.usecase";
-export type { TextGenerationOptions } from "./text-generation.usecase";
-
-export { generateStructured } from "./structured-generation.usecase";
-export type { StructuredGenerationOptions } from "./structured-generation.usecase";
-
-export { streamText } from "./streaming.usecase";
-export type { StreamingCallbacks, StreamingOptions } from "./streaming.usecase";
-
-export {
-  chatSessionManager,
-  type ChatSession,
-  type ChatSendResult,
-} from "./chat-session.usecase";

package/src/domain/entities/index.ts

@@ -1,7 +0,0 @@
-/**
- * Domain Entities
- */
-
-export * from "./groq.types";
-export * from "./models";
-export * from "./error.types";

package/src/infrastructure/http/index.ts

@@ -1,7 +0,0 @@
-/**
- * Infrastructure HTTP Layer
- * HTTP communication with Groq API
- */
-
-export { groqHttpClient } from "./groq-http-client";
-export { streamChatCompletion } from "./streaming-client";

package/src/infrastructure/telemetry/index.ts

@@ -1,5 +0,0 @@
-/**
- * Telemetry
- */
-
-export { telemetry, useTelemetry } from "./TelemetryHooks";

package/src/infrastructure/utils/async/index.ts

@@ -1,6 +0,0 @@
-/**
- * Async utilities
- */
-
-export { executeWithState, executeWithRetry } from "./execute-state.util";
-export type { AsyncStateSetters, AsyncCallbacks } from "./execute-state.util";

package/src/infrastructure/utils/index.ts

@@ -1,8 +0,0 @@
-/**
- * Infrastructure Utilities
- */
-
-export * from "./content-mapper.util";
-export * from "./error-mapper.util";
-export * from "./calculation.util";
-export * from "./async";

package/src/presentation/hooks/index.ts

@@ -1,7 +0,0 @@
-/**
- * Presentation Layer - Hooks
- * React hooks for UI integration
- */
-
-export { useGroq } from "./use-groq.hook";
-export type { UseGroqOptions, UseGroqReturn } from "./use-groq.hook";