@umituz/react-native-ai-groq-provider 1.0.23 → 1.0.25

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;
@@ -32,8 +32,12 @@ export class RequestBuilder {
     return {
       model,
       messages,
-      temperature: generationConfig.temperature ?? defaultTemperature,
-      max_tokens: generationConfig.maxTokens ?? defaultMaxTokens,
+      temperature: generationConfig.temperature !== undefined
+        ? generationConfig.temperature
+        : defaultTemperature,
+      max_tokens: generationConfig.maxTokens !== undefined
+        ? generationConfig.maxTokens
+        : defaultMaxTokens,
       top_p: generationConfig.topP,
       n: generationConfig.n,
       stop: generationConfig.stop,

package/src/shared/response-handler.ts

@@ -0,0 +1,81 @@
+/**
+ * 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;
+}
+
+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 {
+    if (!response.choices || response.choices.length === 0) {
+      return "";
+    }
+    return response.choices[0].message?.content || "";
+  }
+
+  /**
+   * Handle complete response and extract all relevant data
+   */
+  static handleResponse(response: GroqChatResponse): ResponseHandlerResult {
+    if (!response.choices || response.choices.length === 0) {
+      return {
+        content: "",
+        usage: this.extractUsage(response.usage),
+        finishReason: "stop",
+      };
+    }
+
+    const choice = response.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
+   */
+  static logResponse(logger: Logger, response: GroqChatResponse, apiMs: number): void {
+    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: response.choices[0]?.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";

package/src/presentation/hooks/useGroq.ts

@@ -1,235 +0,0 @@
-/**
- * useGroq Hook
- * Main React hook for Groq text generation
- */
-
-import { useState, useCallback, useRef, useMemo } from "react";
-import type { GroqGenerationConfig } from "../../domain/entities";
-import { textGeneration } from "../../infrastructure/services/TextGeneration";
-import { structuredText } from "../../infrastructure/services/StructuredText";
-import { streaming } from "../../infrastructure/services/Streaming";
-import { getUserFriendlyError } from "../../infrastructure/utils/error-mapper.util";
-import { telemetry } from "../../infrastructure/telemetry";
-
-export interface UseGroqOptions {
-  /** Initial model to use */
-  model?: string;
-  /** Default generation config */
-  generationConfig?: GroqGenerationConfig;
-  /** Callback when generation starts */
-  onStart?: () => void;
-  /** Callback when generation completes */
-  onSuccess?: (result: string) => void;
-  /** Callback when generation fails */
-  onError?: (error: string) => void;
-}
-
-export interface UseGroqReturn {
-  /** Loading state */
-  isLoading: boolean;
-  /** Error message */
-  error: string | null;
-  /** Generated result */
-  result: string | null;
-  /** Generate text from a prompt */
-  generate: (prompt: string, options?: GroqGenerationConfig) => Promise<string>;
-  /** Generate structured JSON output */
-  generateJSON: <T = Record<string, unknown>>(
-    prompt: string,
-    options?: GroqGenerationConfig & { schema?: Record<string, unknown> }
-  ) => Promise<T>;
-  /** Stream text generation */
-  stream: (
-    prompt: string,
-    onChunk: (chunk: string) => void,
-    options?: GroqGenerationConfig
-  ) => Promise<void>;
-  /** Reset state */
-  reset: () => void;
-  /** Clear error */
-  clearError: () => void;
-}
-
-/**
- * Hook for Groq text generation
- * Optimized to prevent unnecessary re-renders and memory leaks
- */
-export function useGroq(options: UseGroqOptions = {}): UseGroqReturn {
-  const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-  const [result, setResult] = useState<string | null>(null);
-  const abortControllerRef = useRef<AbortController | null>(null);
-
-  // Memoize options to prevent unnecessary callback recreations
-  const stableOptions = useMemo(() => options, [
-    options.model,
-    options.generationConfig?.temperature,
-    options.generationConfig?.maxTokens,
-    options.generationConfig?.topP,
-    options.onStart,
-    options.onSuccess,
-    options.onError,
-  ]);
-
-  const generate = useCallback(
-    async (prompt: string, config?: GroqGenerationConfig): Promise<string> => {
-      // Cancel any ongoing request
-      if (abortControllerRef.current) {
-        abortControllerRef.current.abort();
-      }
-
-      abortControllerRef.current = new AbortController();
-      setIsLoading(true);
-      setError(null);
-      setResult(null);
-
-      telemetry.log("groq_generate_start", { prompt: prompt.substring(0, 100) });
-      stableOptions.onStart?.();
-
-      try {
-        const response = await textGeneration(prompt, {
-          model: stableOptions.model,
-          generationConfig: { ...stableOptions.generationConfig, ...config },
-        });
-
-        setResult(response);
-        stableOptions.onSuccess?.(response);
-        telemetry.log("groq_generate_success", { responseLength: response.length });
-
-        return response;
-      } catch (err) {
-        const errorMessage = getUserFriendlyError(err);
-        setError(errorMessage);
-        stableOptions.onError?.(errorMessage);
-        telemetry.log("groq_generate_error", { error: errorMessage });
-        throw err;
-      } finally {
-        setIsLoading(false);
-        abortControllerRef.current = null;
-      }
-    },
-    [stableOptions]
-  );
-
-  const generateJSON = useCallback(
-    async <T = Record<string, unknown>,>(
-      prompt: string,
-      config?: GroqGenerationConfig & { schema?: Record<string, unknown> }
-    ): Promise<T> => {
-      // Cancel any ongoing request
-      if (abortControllerRef.current) {
-        abortControllerRef.current.abort();
-      }
-
-      abortControllerRef.current = new AbortController();
-      setIsLoading(true);
-      setError(null);
-      setResult(null);
-
-      telemetry.log("groq_generate_json_start", { prompt: prompt.substring(0, 100) });
-      stableOptions.onStart?.();
-
-      try {
-        const response = await structuredText<T>(prompt, {
-          model: stableOptions.model,
-          generationConfig: { ...stableOptions.generationConfig, ...config },
-          schema: config?.schema,
-        });
-
-        setResult(JSON.stringify(response, null, 2));
-        stableOptions.onSuccess?.(JSON.stringify(response, null, 2));
-        telemetry.log("groq_generate_json_success");
-
-        return response;
-      } catch (err) {
-        const errorMessage = getUserFriendlyError(err);
-        setError(errorMessage);
-        stableOptions.onError?.(errorMessage);
-        telemetry.log("groq_generate_json_error", { error: errorMessage });
-        throw err;
-      } finally {
-        setIsLoading(false);
-        abortControllerRef.current = null;
-      }
-    },
-    [stableOptions]
-  );
-
-  const stream = useCallback(
-    async (
-      prompt: string,
-      onChunk: (chunk: string) => void,
-      config?: GroqGenerationConfig
-    ): Promise<void> => {
-      // Cancel any ongoing request
-      if (abortControllerRef.current) {
-        abortControllerRef.current.abort();
-      }
-
-      abortControllerRef.current = new AbortController();
-      setIsLoading(true);
-      setError(null);
-      setResult(null);
-
-      let fullContent = "";
-
-      telemetry.log("groq_stream_start", { prompt: prompt.substring(0, 100) });
-      stableOptions.onStart?.();
-
-      try {
-        for await (const streamingResult of streaming(prompt, {
-          model: stableOptions.model,
-          generationConfig: { ...stableOptions.generationConfig, ...config },
-          callbacks: {
-            onChunk: (c) => {
-              fullContent += c;
-              onChunk(c);
-            },
-          },
-        })) {
-          // Consume the async iterator (streaming is handled via callbacks)
-          void streamingResult;
-        }
-
-        setResult(fullContent);
-        stableOptions.onSuccess?.(fullContent);
-        telemetry.log("groq_stream_success", { contentLength: fullContent.length });
-      } catch (err) {
-        const errorMessage = getUserFriendlyError(err);
-        setError(errorMessage);
-        stableOptions.onError?.(errorMessage);
-        telemetry.log("groq_stream_error", { error: errorMessage });
-        throw err;
-      } finally {
-        setIsLoading(false);
-        abortControllerRef.current = null;
-      }
-    },
-    [stableOptions]
-  );
-
-  const reset = useCallback(() => {
-    if (abortControllerRef.current) {
-      abortControllerRef.current.abort();
-      abortControllerRef.current = null;
-    }
-    setIsLoading(false);
-    setError(null);
-    setResult(null);
-  }, []);
-
-  const clearError = useCallback(() => {
-    setError(null);
-  }, []);
-
-  return {
-    isLoading,
-    error,
-    result,
-    generate,
-    generateJSON,
-    stream,
-    reset,
-    clearError,
-  };
-}