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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-groq-provider",
-  "version": "1.0.25",
+  "version": "1.0.27",
   "description": "Groq text generation provider for React Native applications",
   "main": "./src/index.ts",
   "types": "./dist/index.d.ts",

package/src/application/use-cases/chat-session.usecase.ts

@@ -35,9 +35,15 @@ class ChatSessionManager {
   private sessions = new Map<string, ChatSession>();
   private readonly MAX_SESSIONS = 100;
   private readonly SESSION_TTL_MS = 24 * 60 * 60 * 1000;
+  private oldestSessionId: string | null = null;
+  private cleanupScheduled = false;
+  private readonly CLEANUP_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
 
   create(config: GroqChatConfig = {}): ChatSession {
-    this.cleanupOldSessions();
+    // Lazy cleanup - only check when needed, not every time
+    if (this.sessions.size >= this.MAX_SESSIONS || !this.cleanupScheduled) {
+      this.scheduleCleanup();
+    }
 
     const session: ChatSession = {
       id: generateSessionId("groq-chat"),
@@ -50,8 +56,16 @@ class ChatSessionManager {
 
     this.sessions.set(session.id, session);
 
-    if (this.sessions.size > this.MAX_SESSIONS) {
-      this.removeOldestSessions();
+    // Track oldest session for O(1) removal
+    if (!this.oldestSessionId ||
+        this.sessions.get(this.oldestSessionId)!.createdAt > session.createdAt) {
+      this.oldestSessionId = session.id;
+    }
+
+    // Fast path: if at limit, just remove oldest
+    if (this.sessions.size > this.MAX_SESSIONS && this.oldestSessionId) {
+      this.sessions.delete(this.oldestSessionId);
+      this.updateOldestSessionId();
     }
 
     return session;
@@ -62,33 +76,52 @@ class ChatSessionManager {
   }
 
   delete(sessionId: string): boolean {
-    return this.sessions.delete(sessionId);
+    const deleted = this.sessions.delete(sessionId);
+    if (deleted && sessionId === this.oldestSessionId) {
+      this.updateOldestSessionId();
+    }
+    return deleted;
   }
 
-  private cleanupOldSessions(): void {
-    const now = Date.now();
-    const expiredIds: string[] = [];
+  private scheduleCleanup(): void {
+    if (this.cleanupScheduled) return;
+
+    this.cleanupScheduled = true;
+    // Schedule cleanup for next idle time
+    setTimeout(() => {
+      this.cleanupOldSessions();
+      this.cleanupScheduled = false;
+    }, this.CLEANUP_INTERVAL_MS);
+  }
+
+  private updateOldestSessionId(): void {
+    let oldest: Date | null = null;
+    let oldestId: string | null = null;
 
     for (const [id, session] of this.sessions.entries()) {
-      const age = now - session.updatedAt.getTime();
-      if (age > this.SESSION_TTL_MS) {
-        expiredIds.push(id);
+      if (!oldest || session.createdAt < oldest) {
+        oldest = session.createdAt;
+        oldestId = id;
       }
     }
 
-    expiredIds.forEach((id) => this.sessions.delete(id));
+    this.oldestSessionId = oldestId;
   }
 
-  private removeOldestSessions(): void {
-    const excessCount = this.sessions.size - this.MAX_SESSIONS;
-    if (excessCount <= 0) return;
+  private cleanupOldSessions(): void {
+    const now = Date.now();
+    let removed = 0;
 
-    // Sort by creation date and remove oldest
-    const sorted = Array.from(this.sessions.entries())
-      .sort(([, a], [, b]) => a.createdAt.getTime() - b.createdAt.getTime());
+    for (const [id, session] of this.sessions.entries()) {
+      const age = now - session.updatedAt.getTime();
+      if (age > this.SESSION_TTL_MS) {
+        this.sessions.delete(id);
+        removed++;
+      }
+    }
 
-    for (let i = 0; i < excessCount; i++) {
-      this.sessions.delete(sorted[i][0]);
+    if (removed > 0) {
+      this.updateOldestSessionId();
     }
   }
 
@@ -104,6 +137,11 @@ class ChatSessionManager {
     const userMessage: GroqMessage = { role: "user", content };
     session.messages.push(userMessage);
 
+    // Prevent unbounded memory growth
+    if (session.messages.length > 100) {
+      session.messages = session.messages.slice(-50); // Keep last 50
+    }
+
     const messages = this.buildMessages(session);
     const request = RequestBuilder.buildChatRequest(messages, {
       model: session.model,

package/src/application/use-cases/structured-generation.usecase.ts

@@ -1,6 +1,7 @@
 /**
  * Structured Generation Use Case
  * Generates structured JSON output from prompts
+ * Optimized for performance
  */
 
 import type { GroqGenerationConfig } from "../../domain/entities/groq.types";
@@ -12,7 +13,7 @@ import { ResponseHandler } from "../../shared/response-handler";
 import { GroqError, GroqErrorType } from "../../domain/entities/error.types";
 import { cleanJsonResponse } from "../../infrastructure/utils/content-mapper.util";
 
-const MAX_CONTENT_LENGTH_FOR_ERROR = 200; // Truncate content in error messages
+const MAX_CONTENT_LENGTH_FOR_ERROR = 200;
 
 export interface StructuredGenerationOptions<T> {
   model?: string;
@@ -57,7 +58,6 @@ export async function generateStructured<T = Record<string, unknown>>(
   try {
     const parsed = JSON.parse(content) as T;
 
-    // Validate that result is an object
     if (typeof parsed !== 'object' || parsed === null) {
       throw new Error("Response is not a valid object");
     }
@@ -80,7 +80,7 @@ export async function generateStructured<T = Record<string, unknown>>(
 
     throw new GroqError(
       GroqErrorType.UNKNOWN_ERROR,
-      `Failed to parse JSON response. Expected valid JSON object but got: ${truncatedContent}`,
+      `Failed to parse JSON response: ${truncatedContent}`,
       error
     );
   }
@@ -92,12 +92,17 @@ function buildSystemPrompt<T>(
 ): string {
   let prompt = "You are a helpful assistant that generates valid JSON output.";
 
-  if (schema) {
-    prompt += `\n\nResponse must conform to this JSON schema:\n${JSON.stringify(schema, null, 2)}`;
-  }
+  if (schema || example) {
+    prompt += "\n\nResponse requirements:";
+
+    if (schema) {
+      // Use compact JSON to reduce tokens and improve speed
+      prompt += `\nSchema: ${JSON.stringify(schema)}`;
+    }
 
-  if (example) {
-    prompt += `\n\nExample response format:\n${JSON.stringify(example, null, 2)}`;
+    if (example) {
+      prompt += `\nExample: ${JSON.stringify(example)}`;
+    }
   }
 
   prompt += "\n\nIMPORTANT: Respond ONLY with valid JSON. No markdown, no code blocks.";

package/src/infrastructure/http/streaming-client.ts

@@ -1,6 +1,7 @@
 /**
  * Streaming Client
  * Handles SSE streaming from Groq API
+ * Optimized for performance and memory efficiency
  */
 
 import type { GroqChatRequest, GroqChatChunk } from "../../domain/entities/groq.types";
@@ -9,7 +10,7 @@ import { logger } from "../../shared/logger";
 
 const DEFAULT_TIMEOUT = 60000;
 const MAX_BUFFER_SIZE = 1024 * 1024; // 1MB
-const MAX_INCOMPLETE_CHUNKS = 10; // Max consecutive parse failures
+const MAX_INCOMPLETE_CHUNKS = 10;
 
 export async function* streamChatCompletion(
   request: GroqChatRequest,
@@ -21,14 +22,14 @@ export async function* streamChatCompletion(
 
 class GroqStreamingClient {
   private normalizeBaseUrl(baseUrl: string): string {
-    return baseUrl.replace(/\/+$/, ""); // Remove trailing slashes
+    return baseUrl.replace(/\/+$/, "");
   }
 
   private validateTimeout(timeout?: number): number {
     if (timeout === undefined || timeout === null || timeout <= 0) {
       return DEFAULT_TIMEOUT;
     }
-    return Math.min(timeout, 300000); // Cap at 5 minutes
+    return Math.min(timeout, 300000);
   }
 
   async* stream(
@@ -39,9 +40,7 @@ class GroqStreamingClient {
     const url = `${baseUrl}/chat/completions`;
     const timeout = this.validateTimeout(config.timeoutMs);
 
-    logger.debug("StreamingClient", "Starting stream", {
-      model: request.model,
-    });
+    logger.debug("StreamingClient", "Starting stream", { model: request.model });
 
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeout);
@@ -79,6 +78,7 @@ class GroqStreamingClient {
   private async* parseSSE(body: ReadableStream<Uint8Array>): AsyncGenerator<GroqChatChunk> {
     const reader = body.getReader();
     const decoder = new TextDecoder();
+    const chunks: string[] = []; // Array for efficient string building
     let buffer = "";
     let consecutiveErrors = 0;
 
@@ -87,17 +87,20 @@ class GroqStreamingClient {
         const { done, value } = await reader.read();
         if (done) break;
 
-        buffer += decoder.decode(value, { stream: true });
+        chunks.push(decoder.decode(value, { stream: true }));
 
-        // Safe buffer management - only trim if necessary
+        // Join all chunks at once - more efficient than +=
+        buffer = chunks.join("");
+        chunks.length = 0; // Clear array
+
+        // Trim buffer if necessary
         if (buffer.length > MAX_BUFFER_SIZE) {
-          const keepSize = Math.floor(MAX_BUFFER_SIZE / 2);
-          buffer = buffer.slice(-keepSize);
-          logger.warn("StreamingClient", "Buffer trimmed due to size limit");
+          buffer = buffer.slice(-Math.floor(MAX_BUFFER_SIZE / 2));
+          logger.warn("StreamingClient", "Buffer trimmed");
         }
 
         const lines = buffer.split("\n");
-        buffer = lines.pop() || ""; // Keep incomplete line in buffer
+        buffer = lines.pop() || "";
 
         for (const line of lines) {
           const trimmed = line.trim();
@@ -107,21 +110,19 @@ class GroqStreamingClient {
             try {
               const jsonStr = trimmed.slice(6);
               const chunk = JSON.parse(jsonStr) as GroqChatChunk;
-              consecutiveErrors = 0; // Reset error counter on success
+              consecutiveErrors = 0;
               yield chunk;
             } catch (error) {
               consecutiveErrors++;
-              logger.error("StreamingClient", "Failed to parse SSE chunk", {
-                error,
-                chunk: trimmed.substring(0, 100),
+              logger.error("StreamingClient", "Parse error", {
+                error: error instanceof Error ? error.message : String(error),
                 consecutiveErrors,
               });
 
-              // After too many consecutive errors, abort the stream
               if (consecutiveErrors >= MAX_INCOMPLETE_CHUNKS) {
                 throw new GroqError(
                   GroqErrorType.SERVER_ERROR,
-                  `Stream corrupted: ${consecutiveErrors} consecutive parse failures`
+                  `Stream corrupted: ${consecutiveErrors} parse failures`
                 );
               }
             }

package/src/infrastructure/telemetry/TelemetryHooks.ts

@@ -1,9 +1,10 @@
 /**
  * Telemetry Hooks
  * Simple telemetry tracking for Groq operations
+ * Optimized with O(1) circular buffer
  */
 
-import { useMemo, useRef } from "react";
+import { useMemo } from "react";
 
 type TelemetryEvent = {
   name: string;
@@ -15,15 +16,15 @@ class Telemetry {
   private events: TelemetryEvent[] = [];
   private enabled: boolean;
   private readonly MAX_EVENTS = 1000;
-  private nextIndex = 0; // For circular buffer
-  private isCircular = false; // Track when we've wrapped around
+  private head = 0; // Write position
+  private count = 0; // Actual number of events
 
   constructor() {
     this.enabled = typeof __DEV__ !== "undefined" && __DEV__;
   }
 
   /**
-   * Log a telemetry event
+   * Log a telemetry event - O(1) operation
    */
   log(name: string, data?: Record<string, unknown>): void {
     if (!this.enabled) return;
@@ -34,43 +35,44 @@ class Telemetry {
       data,
     };
 
-    // Use circular buffer pattern for O(1) insertion
-    if (this.events.length < this.MAX_EVENTS) {
-      this.events.push(event);
-    } else {
-      // Circular buffer: overwrite oldest event
-      this.events[this.nextIndex] = event;
-      this.nextIndex = (this.nextIndex + 1) % this.MAX_EVENTS;
-      this.isCircular = true;
-    }
+    // Circular buffer: O(1) write
+    this.events[this.head] = event;
+    this.head = (this.head + 1) % this.MAX_EVENTS;
 
-    if (__DEV__) {
-      console.log(`[Groq Telemetry] ${name}`, data);
+    if (this.count < this.MAX_EVENTS) {
+      this.count++;
     }
   }
 
   /**
-   * Get all events
+   * Get all events in chronological order
+   * Returns frozen array to prevent external mutations
    */
   getEvents(): ReadonlyArray<TelemetryEvent> {
-    if (this.isCircular) {
-      // Return events in circular order (oldest first)
-      const result = [
-        ...this.events.slice(this.nextIndex),
-        ...this.events.slice(0, this.nextIndex),
-      ];
-      return Object.freeze(result);
+    if (this.count === 0) {
+      return Object.freeze([]);
+    }
+
+    // O(n) but only when called, not on every log
+    if (this.count < this.MAX_EVENTS) {
+      // Not wrapped yet, just return slice
+      return Object.freeze(this.events.slice(0, this.count));
+    }
+
+    // Wrapped around - need to reorder
+    const result: TelemetryEvent[] = new Array(this.count);
+    for (let i = 0; i < this.count; i++) {
+      result[i] = this.events[(this.head + i) % this.MAX_EVENTS];
     }
-    return Object.freeze(this.events);
+    return Object.freeze(result);
   }
 
   /**
-   * Clear all events
+   * Clear all events - O(1)
    */
   clear(): void {
-    this.events.length = 0;
-    this.nextIndex = 0;
-    this.isCircular = false;
+    this.head = 0;
+    this.count = 0;
   }
 
   /**
@@ -91,10 +93,10 @@ class Telemetry {
   }
 
   /**
-   * Get event count (lightweight check)
+   * Get event count - O(1)
    */
   getEventCount(): number {
-    return this.isCircular ? this.MAX_EVENTS : this.events.length;
+    return this.count;
   }
 }
 
@@ -105,16 +107,17 @@ export const telemetry = new Telemetry();
 
 /**
  * Hook to use telemetry in components
- * Optimized with useMemo to prevent unnecessary re-renders
+ * Memoized to prevent unnecessary re-renders
  */
 export function useTelemetry() {
-  const methodsRef = useRef({
-    log: telemetry.log.bind(telemetry),
-    getEvents: telemetry.getEvents.bind(telemetry),
-    clear: telemetry.clear.bind(telemetry),
-    isEnabled: telemetry.isEnabled.bind(telemetry),
-    getEventCount: telemetry.getEventCount.bind(telemetry),
-  });
-
-  return useMemo(() => methodsRef.current, []);
+  return useMemo(
+    () => ({
+      log: telemetry.log.bind(telemetry),
+      getEvents: telemetry.getEvents.bind(telemetry),
+      clear: telemetry.clear.bind(telemetry),
+      isEnabled: telemetry.isEnabled.bind(telemetry),
+      getEventCount: telemetry.getEventCount.bind(telemetry),
+    }),
+    []
+  );
 }

package/src/infrastructure/utils/calculation.util.ts

@@ -1,25 +1,23 @@
 /**
  * Calculation Utilities
  * Common calculation and utility functions for numeric operations
+ * Optimized for performance
  */
 
-const MAX_RANDOM_ID_LENGTH = 11; // Max chars from Math.random().toString(36)
+const MAX_RANDOM_ID_LENGTH = 11;
 
 /**
  * Generate a random unique identifier string
- * @param length - Length of the random string (default: 9, max: 11)
- * @returns Random string in base-36
+ * Uses optimized single-pass operations
  */
 export function generateRandomId(length: number = 9): string {
   const safeLength = Math.min(Math.max(1, Math.floor(length)), MAX_RANDOM_ID_LENGTH);
-  const randomStr = Math.random().toString(36).substring(2);
-  return randomStr.substring(0, safeLength);
+  const randomStr = Math.random().toString(36).substring(2, 2 + safeLength);
+  return randomStr;
 }
 
 /**
  * Generate a unique chat session ID
- * @param prefix - Optional prefix for the ID (default: "groq-chat")
- * @returns Unique session identifier
  */
 export function generateSessionId(prefix: string = "groq-chat"): string {
   return `${prefix}-${Date.now()}-${generateRandomId(9)}`;
@@ -27,19 +25,13 @@ export function generateSessionId(prefix: string = "groq-chat"): string {
 
 /**
  * Calculate maximum number of messages based on token limit
- * Uses a heuristic of approximately 100 tokens per message
- * @param maxTokens - Maximum allowed tokens
- * @param tokensPerMessage - Estimated tokens per message (default: 100)
- * @returns Maximum number of messages
  */
 export function calculateMaxMessages(
   maxTokens: number,
   tokensPerMessage: number = 100
 ): number {
-  if (!Number.isFinite(maxTokens) || maxTokens <= 0) {
-    return 0;
-  }
-  if (!Number.isFinite(tokensPerMessage) || tokensPerMessage <= 0) {
+  if (!Number.isFinite(maxTokens) || maxTokens <= 0 ||
+      !Number.isFinite(tokensPerMessage) || tokensPerMessage <= 0) {
     return 0;
   }
   return Math.floor(maxTokens / tokensPerMessage);
@@ -47,12 +39,10 @@ export function calculateMaxMessages(
 
 /**
  * Calculate exponential backoff delay
- * @param baseDelay - Initial delay in milliseconds
- * @param attempt - Current attempt number (0-indexed)
- * @returns Delay in milliseconds
  */
 export function calculateExponentialBackoff(baseDelay: number, attempt: number): number {
-  if (!Number.isFinite(baseDelay) || baseDelay < 0 || !Number.isFinite(attempt) || attempt < 0) {
+  if (!Number.isFinite(baseDelay) || baseDelay < 0 ||
+      !Number.isFinite(attempt) || attempt < 0) {
     return 0;
   }
   return baseDelay * Math.pow(2, attempt);
@@ -60,10 +50,6 @@ export function calculateExponentialBackoff(baseDelay: number, attempt: number):
 
 /**
  * Clamp a value between min and max
- * @param value - Value to clamp
- * @param min - Minimum allowed value
- * @param max - Maximum allowed value
- * @returns Clamped value
  */
 export function clamp(value: number, min: number, max: number): number {
   if (!Number.isFinite(value)) return min;
@@ -74,10 +60,7 @@ export function clamp(value: number, min: number, max: number): number {
 
 /**
  * Calculate percentage with optional decimal places
- * @param value - Current value
- * @param total - Total value
- * @param decimals - Number of decimal places (default: 2)
- * @returns Percentage value
+ * Optimized: avoids string conversion
  */
 export function calculatePercentage(
   value: number,
@@ -87,16 +70,12 @@ export function calculatePercentage(
   if (!Number.isFinite(value) || !Number.isFinite(total) || total === 0) {
     return 0;
   }
-  const safeDecimals = Math.max(0, Math.min(20, Math.floor(decimals)));
-  return Number(((value / total) * 100).toFixed(safeDecimals));
+  const multiplier = Math.pow(10, Math.max(0, Math.min(20, Math.floor(decimals))));
+  return Math.round((value / total) * 100 * multiplier) / multiplier;
 }
 
 /**
  * Calculate buffer size limit for streaming
- * Ensures buffer doesn't grow beyond reasonable limits
- * @param currentSize - Current buffer size
- * @param maxSize - Maximum allowed buffer size
- * @returns Safe buffer size
  */
 export function calculateSafeBufferSize(currentSize: number, maxSize: number): number {
   if (!Number.isFinite(currentSize) || !Number.isFinite(maxSize) || maxSize <= 0) {
@@ -110,22 +89,14 @@ export function calculateSafeBufferSize(currentSize: number, maxSize: number): n
 
 /**
  * Calculate token estimate from text
- * Rough approximation: ~4 characters per token
- * @param text - Text to estimate tokens for
- * @returns Estimated token count
  */
 export function estimateTokens(text: string): number {
-  if (!text) {
-    return 0;
-  }
+  if (!text) return 0;
   return Math.ceil(text.length / 4);
 }
 
 /**
  * Calculate if message count is within safe limits
- * @param messageCount - Current message count
- * @param maxMessages - Maximum allowed messages
- * @returns Whether within safe limits
  */
 export function isWithinSafeLimit(messageCount: number, maxMessages: number): boolean {
   return Number.isFinite(messageCount) &&
@@ -136,11 +107,6 @@ export function isWithinSafeLimit(messageCount: number, maxMessages: number): bo
 
 /**
  * Calculate retry delay with jitter
- * Adds random jitter to prevent thundering herd
- * @param baseDelay - Base delay in milliseconds
- * @param attempt - Current attempt number
- * @param jitterFactor - Jitter factor (0-1, default: 0.1)
- * @returns Delay with jitter applied
  */
 export function calculateRetryDelayWithJitter(
   baseDelay: number,
@@ -159,11 +125,6 @@ export function calculateRetryDelayWithJitter(
 
 /**
  * Calculate timeout for network requests
- * Based on exponential backoff with a maximum cap
- * @param attempt - Current attempt number
- * @param baseTimeout - Base timeout in milliseconds (default: 5000)
- * @param maxTimeout - Maximum timeout in milliseconds (default: 30000)
- * @returns Timeout in milliseconds
  */
 export function calculateRequestTimeout(
   attempt: number,
@@ -181,33 +142,36 @@ export function calculateRequestTimeout(
 
 /**
  * Calculate data transfer rate
- * @param bytes - Number of bytes transferred
- * @param milliseconds - Time taken in milliseconds
- * @returns Transfer rate in KB/s
  */
 export function calculateTransferRate(bytes: number, milliseconds: number): number {
   if (!Number.isFinite(bytes) || bytes < 0 ||
       !Number.isFinite(milliseconds) || milliseconds <= 0) {
     return 0;
   }
-  const seconds = milliseconds / 1000;
-  const kilobytes = bytes / 1024;
-  return Number((kilobytes / seconds).toFixed(2));
+  const kilobytesPerSecond = (bytes / 1024) * (1000 / milliseconds);
+  return Math.round(kilobytesPerSecond * 100) / 100;
 }
 
 /**
  * Calculate average from array of numbers
- * @param values - Array of numbers
- * @returns Average value or 0 if array is empty
+ * Optimized: Single pass with inline validation
  */
 export function calculateAverage(values: number[]): number {
   if (!Array.isArray(values) || values.length === 0) {
     return 0;
   }
-  const validValues = values.filter(v => Number.isFinite(v));
-  if (validValues.length === 0) {
-    return 0;
+
+  let sum = 0;
+  let count = 0;
+
+  // Single pass: validate and sum
+  for (let i = 0; i < values.length; i++) {
+    const v = values[i];
+    if (Number.isFinite(v)) {
+      sum += v;
+      count++;
+    }
   }
-  const sum = validValues.reduce((acc, val) => acc + val, 0);
-  return sum / validValues.length;
+
+  return count === 0 ? 0 : sum / count;
 }

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

@@ -3,7 +3,7 @@
  * Main React hook for Groq text generation
  */
 
-import { useState, useCallback, useMemo } from "react";
+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";
@@ -41,14 +41,30 @@ export function useGroq(options: UseGroqOptions = {}): UseGroqReturn {
   const [error, setError] = useState<string | null>(null);
   const [result, setResult] = useState<string | null>(null);
 
-  // Memoize options with proper deep equality check
-  const stableOptions = useMemo(() => options, [
-    options.model,
-    JSON.stringify(options.generationConfig),
-    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> => {
@@ -56,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(
@@ -88,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(
@@ -125,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);
           }},
         })) {
-          fullContent += chunk; // Accumulate all chunks
+          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/shared/request-builder.ts

@@ -29,7 +29,7 @@ export class RequestBuilder {
       defaultMaxTokens = 1024,
     } = options;
 
-    return {
+    const request: GroqChatRequest = {
       model,
       messages,
       temperature: generationConfig.temperature !== undefined
@@ -38,12 +38,27 @@ export class RequestBuilder {
       max_tokens: generationConfig.maxTokens !== undefined
         ? generationConfig.maxTokens
         : defaultMaxTokens,
-      top_p: generationConfig.topP,
-      n: generationConfig.n,
-      stop: generationConfig.stop,
-      frequency_penalty: generationConfig.frequencyPenalty,
-      presence_penalty: generationConfig.presencePenalty,
     };
+
+    // 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

@@ -7,6 +7,7 @@ import type { GroqChatResponse, GroqUsage, GroqFinishReason } from "../domain/en
 
 interface Logger {
   debug: (tag: string, message: string, context?: Record<string, unknown>) => void;
+  isEnabled?: () => boolean;
 }
 
 export interface ResponseHandlerResult {
@@ -24,17 +25,20 @@ export class ResponseHandler {
    * Extract content from chat completion response
    */
   static extractContent(response: GroqChatResponse): string {
-    if (!response.choices || response.choices.length === 0) {
+    const choices = response.choices;
+    if (!choices || choices.length === 0) {
       return "";
     }
-    return response.choices[0].message?.content || "";
+    return choices[0].message?.content || "";
   }
 
   /**
    * Handle complete response and extract all relevant data
    */
   static handleResponse(response: GroqChatResponse): ResponseHandlerResult {
-    if (!response.choices || response.choices.length === 0) {
+    const choices = response.choices;
+
+    if (!choices || choices.length === 0) {
       return {
         content: "",
         usage: this.extractUsage(response.usage),
@@ -42,7 +46,7 @@ export class ResponseHandler {
       };
     }
 
-    const choice = response.choices[0];
+    const choice = choices[0];
     return {
       content: choice.message?.content || "",
       usage: this.extractUsage(response.usage),
@@ -66,15 +70,23 @@ export class ResponseHandler {
   }
 
   /**
-   * Log response details
+   * 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: response.choices[0]?.finish_reason,
+      finishReason: firstChoice?.finish_reason,
       apiDuration: `${apiMs}ms`,
     });
   }