@umituz/react-native-ai-groq-provider 1.0.20 → 1.0.22

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

@@ -0,0 +1,125 @@
+/**
+ * Streaming Client
+ * Handles SSE streaming from Groq API
+ */
+
+import type { GroqChatRequest, GroqChatChunk } from "../../domain/entities";
+import { GroqError, GroqErrorType, mapHttpStatusToErrorType } from "../../domain/entities/error.types";
+import { logger } from "../../shared/logger";
+import { calculateSafeBufferSize } from "../../utils/calculation.util";
+
+const DEFAULT_TIMEOUT = 60000;
+
+export async function* streamChatCompletion(
+  request: GroqChatRequest,
+  config: { apiKey: string; baseUrl: string; timeoutMs?: number }
+): AsyncGenerator<GroqChatChunk> {
+  const url = `${config.baseUrl}/chat/completions`;
+  const timeout = config.timeoutMs || DEFAULT_TIMEOUT;
+
+  logger.debug("StreamingClient", "Starting stream", {
+    model: request.model,
+  });
+
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${config.apiKey}`,
+      },
+      body: JSON.stringify({ ...request, stream: true }),
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeoutId);
+
+    if (!response.ok) {
+      await handleErrorResponse(response);
+    }
+
+    if (!response.body) {
+      throw new GroqError(GroqErrorType.NETWORK_ERROR, "Response body is null");
+    }
+
+    yield* parseSSE(response.body);
+
+  } catch (error) {
+    throw handleRequestError(error);
+  }
+}
+
+async function* parseSSE(body: ReadableStream<Uint8Array>): AsyncGenerator<GroqChatChunk> {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const MAX_BUFFER_SIZE = 1024 * 1024;
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+
+      const safeSize = calculateSafeBufferSize(buffer.length, MAX_BUFFER_SIZE);
+      if (safeSize < buffer.length) {
+        buffer = buffer.slice(-safeSize);
+      }
+
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed === "data: [DONE]") continue;
+
+        if (trimmed.startsWith("data: ")) {
+          try {
+            const chunk = JSON.parse(trimmed.slice(6)) as GroqChatChunk;
+            yield chunk;
+          } catch (error) {
+            logger.error("StreamingClient", "Failed to parse SSE chunk", { error });
+          }
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+async function handleErrorResponse(response: Response): Promise<never> {
+  let errorMessage = `HTTP ${response.status}`;
+  const errorType = mapHttpStatusToErrorType(response.status);
+
+  try {
+    const errorData = (await response.json()) as { error?: { message?: string } };
+    if (errorData.error?.message) errorMessage = errorData.error.message;
+  } catch {
+    // Use default
+  }
+
+  throw new GroqError(errorType, errorMessage);
+}
+
+function handleRequestError(error: unknown): GroqError {
+  if (error instanceof GroqError) return error;
+
+  if (error instanceof Error) {
+    if (error.name === "AbortError") {
+      return new GroqError(GroqErrorType.ABORT_ERROR, "Request aborted", error);
+    }
+    if (error.message.includes("network")) {
+      return new GroqError(GroqErrorType.NETWORK_ERROR, "Network error", error);
+    }
+  }
+
+  return new GroqError(
+    GroqErrorType.UNKNOWN_ERROR,
+    error instanceof Error ? error.message : "Unknown error"
+  );
+}

package/src/presentation/hooks/index.ts

@@ -0,0 +1,7 @@
+/**
+ * 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/use-groq.hook.ts

@@ -0,0 +1,184 @@
+/**
+ * useGroq Hook
+ * 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";
+
+export interface UseGroqOptions {
+  model?: string;
+  generationConfig?: GroqGenerationConfig;
+  onStart?: () => void;
+  onSuccess?: (result: string) => void;
+  onError?: (error: string) => void;
+}
+
+export interface UseGroqReturn {
+  isLoading: boolean;
+  error: string | null;
+  result: string | null;
+  generate: (prompt: string, config?: GroqGenerationConfig) => Promise<string>;
+  generateJSON: <T = Record<string, unknown>>(
+    prompt: string,
+    config?: GroqGenerationConfig & { schema?: Record<string, unknown> }
+  ) => Promise<T>;
+  stream: (
+    prompt: string,
+    onChunk: (chunk: string) => void,
+    config?: GroqGenerationConfig
+  ) => Promise<void>;
+  reset: () => void;
+  clearError: () => void;
+}
+
+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 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,
+    ]
+  );
+
+  const generate = useCallback(
+    async (prompt: string, config?: GroqGenerationConfig): Promise<string> => {
+      setIsLoading(true);
+      setError(null);
+      setResult(null);
+
+      stableOptions.onStart?.();
+
+      try {
+        const response = await generateText(prompt, {
+          model: stableOptions.model,
+          generationConfig: { ...stableOptions.generationConfig, ...config },
+        });
+
+        setResult(response);
+        stableOptions.onSuccess?.(response);
+        return response;
+      } catch (err) {
+        const errorMessage = getUserFriendlyError(err);
+        setError(errorMessage);
+        stableOptions.onError?.(errorMessage);
+        throw err;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [stableOptions]
+  );
+
+  const generateJSON = useCallback(
+    async <T = Record<string, unknown>,>(
+      prompt: string,
+      config?: GroqGenerationConfig & { schema?: Record<string, unknown> }
+    ): Promise<T> => {
+      setIsLoading(true);
+      setError(null);
+      setResult(null);
+
+      stableOptions.onStart?.();
+
+      try {
+        const response = await generateStructured<T>(prompt, {
+          model: stableOptions.model,
+          generationConfig: { ...stableOptions.generationConfig, ...config },
+          schema: config?.schema,
+        });
+
+        const jsonStr = JSON.stringify(response, null, 2);
+        setResult(jsonStr);
+        stableOptions.onSuccess?.(jsonStr);
+        return response;
+      } catch (err) {
+        const errorMessage = getUserFriendlyError(err);
+        setError(errorMessage);
+        stableOptions.onError?.(errorMessage);
+        throw err;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [stableOptions]
+  );
+
+  const stream = useCallback(
+    async (
+      prompt: string,
+      onChunk: (chunk: string) => void,
+      config?: GroqGenerationConfig
+    ): Promise<void> => {
+      setIsLoading(true);
+      setError(null);
+      setResult(null);
+
+      let fullContent = "";
+
+      stableOptions.onStart?.();
+
+      try {
+        for await (const chunk of streamText(prompt, {
+          model: stableOptions.model,
+          generationConfig: { ...stableOptions.generationConfig, ...config },
+          callbacks: { onChunk: (c) => {
+            fullContent += c;
+            onChunk(c);
+          }},
+        })) {
+          // Consume iterator
+        }
+
+        setResult(fullContent);
+        stableOptions.onSuccess?.(fullContent);
+      } catch (err) {
+        const errorMessage = getUserFriendlyError(err);
+        setError(errorMessage);
+        stableOptions.onError?.(errorMessage);
+        throw err;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [stableOptions]
+  );
+
+  const reset = useCallback(() => {
+    setIsLoading(false);
+    setError(null);
+    setResult(null);
+  }, []);
+
+  const clearError = useCallback(() => {
+    setError(null);
+  }, []);
+
+  return {
+    isLoading,
+    error,
+    result,
+    generate,
+    generateJSON,
+    stream,
+    reset,
+    clearError,
+  };
+}

package/src/presentation/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Presentation Layer
+ * UI integration components
+ */
+
+export * from "./hooks";

package/src/shared/index.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared Utilities
+ * Common utilities used across all layers
+ */
+
+export { logger, LogLevel } from "./logger";
+export type { LogContext } from "./logger";
+
+export { Timer } from "./timer";
+export type { TimerResult } from "./timer";
+
+export { RequestBuilder } from "./request-builder";
+export type { RequestBuilderOptions } from "./request-builder";
+
+export { ResponseHandler } from "./response-handler";
+export type { ResponseHandlerResult } from "./response-handler";

package/src/shared/logger.ts

@@ -0,0 +1,63 @@
+/**
+ * Logger Utility
+ * Centralized logging for the entire application
+ */
+
+export enum LogLevel {
+  DEBUG = "DEBUG",
+  INFO = "INFO",
+  WARN = "WARN",
+  ERROR = "ERROR",
+}
+
+export interface LogContext {
+  [key: string]: unknown;
+}
+
+class Logger {
+  private enabled: boolean;
+
+  constructor() {
+    this.enabled = typeof __DEV__ !== "undefined" && __DEV__;
+  }
+
+  private log(level: LogLevel, tag: string, message: string, context?: LogContext): void {
+    if (!this.enabled) return;
+
+    const timestamp = new Date().toISOString();
+    const logMessage = `[${timestamp}] [${level}] [${tag}] ${message}`;
+
+    switch (level) {
+      case LogLevel.ERROR:
+        console.error(logMessage, context || "");
+        break;
+      case LogLevel.WARN:
+        console.warn(logMessage, context || "");
+        break;
+      default:
+        console.log(logMessage, context || "");
+    }
+  }
+
+  debug(tag: string, message: string, context?: LogContext): void {
+    this.log(LogLevel.DEBUG, tag, message, context);
+  }
+
+  info(tag: string, message: string, context?: LogContext): void {
+    this.log(LogLevel.INFO, tag, message, context);
+  }
+
+  warn(tag: string, message: string, context?: LogContext): void {
+    this.log(LogLevel.WARN, tag, message, context);
+  }
+
+  error(tag: string, message: string, context?: LogContext): void {
+    this.log(LogLevel.ERROR, tag, message, context);
+  }
+
+  isEnabled(): boolean {
+    return this.enabled;
+  }
+}
+
+export const logger = new Logger();

package/src/shared/request-builder.ts

@@ -0,0 +1,64 @@
+/**
+ * Request Builder Utility
+ * Centralized request building logic
+ */
+
+import type {
+  GroqChatRequest,
+  GroqGenerationConfig,
+  GroqMessage,
+} from "../domain/entities";
+import { DEFAULT_MODELS } from "../domain/entities";
+
+export interface RequestBuilderOptions {
+  model?: string;
+  generationConfig?: GroqGenerationConfig;
+  defaultTemperature?: number;
+  defaultMaxTokens?: number;
+}
+
+export class RequestBuilder {
+  static buildChatRequest(
+    messages: GroqMessage[],
+    options: RequestBuilderOptions = {}
+  ): GroqChatRequest {
+    const {
+      model = DEFAULT_MODELS.TEXT,
+      generationConfig = {},
+      defaultTemperature = 0.7,
+      defaultMaxTokens = 1024,
+    } = options;
+
+    return {
+      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,
+    };
+  }
+
+  static buildPromptRequest(
+    prompt: string,
+    options: RequestBuilderOptions = {}
+  ): GroqChatRequest {
+    const messages: GroqMessage[] = [{ role: "user", content: prompt }];
+    return this.buildChatRequest(messages, options);
+  }
+
+  static buildSystemPromptRequest(
+    systemPrompt: string,
+    userPrompt: string,
+    options: RequestBuilderOptions = {}
+  ): GroqChatRequest {
+    const messages: GroqMessage[] = [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: userPrompt },
+    ];
+    return this.buildChatRequest(messages, options);
+  }
+}

package/src/shared/timer.ts

@@ -0,0 +1,43 @@
+/**
+ * Timer Utility
+ * Performance measurement helper
+ */
+
+export interface TimerResult {
+  totalMs: number;
+  apiMs: number;
+  processingMs: number;
+}
+
+export class Timer {
+  private startTime: number;
+  private apiStartTime?: number;
+  private apiEndTime?: number;
+
+  constructor() {
+    this.startTime = Date.now();
+  }
+
+  startApiCall(): void {
+    this.apiStartTime = Date.now();
+  }
+
+  endApiCall(): void {
+    this.apiEndTime = Date.now();
+  }
+
+  getResult(): TimerResult {
+    const endTime = Date.now();
+    const totalMs = endTime - this.startTime;
+    const apiMs = this.apiEndTime && this.apiStartTime
+      ? this.apiEndTime - this.apiStartTime
+      : 0;
+    const processingMs = totalMs - apiMs;
+
+    return { totalMs, apiMs, processingMs };
+  }
+
+  static format(ms: number): string {
+    return `${ms}ms`;
+  }
+}