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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-groq-provider",
-  "version": "1.0.21",
+  "version": "1.0.22",
   "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

@@ -0,0 +1,137 @@
+/**
+ * Chat Session Use Case
+ * Manages multi-turn chat conversations
+ */
+
+import type { GroqMessage, GroqChatConfig } from "../../domain/entities";
+import { groqHttpClient } from "../../infrastructure/http";
+import { RequestBuilder } from "../../shared/request-builder";
+import { ResponseHandler } from "../../shared/response-handler";
+import { logger } from "../../shared/logger";
+import { GroqError, GroqErrorType } from "../../domain/entities/error.types";
+import { generateSessionId } from "../../utils/calculation.util";
+
+export interface ChatSession {
+  id: string;
+  model: string;
+  systemInstruction?: string;
+  messages: GroqMessage[];
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface ChatSendResult {
+  response: string;
+  usage: {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+  };
+  finishReason: string;
+}
+
+class ChatSessionManager {
+  private sessions = new Map<string, ChatSession>();
+  private readonly MAX_SESSIONS = 100;
+  private readonly SESSION_TTL_MS = 24 * 60 * 60 * 1000;
+
+  create(config: GroqChatConfig = {}): ChatSession {
+    this.cleanupOldSessions();
+
+    const session: ChatSession = {
+      id: generateSessionId("groq-chat"),
+      model: config.model || "llama-3.3-70b-versatile",
+      systemInstruction: config.systemInstruction,
+      messages: config.history ? [...config.history] : [],
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+
+    this.sessions.set(session.id, session);
+
+    if (this.sessions.size > this.MAX_SESSIONS) {
+      const sorted = Array.from(this.sessions.entries())
+        .sort(([, a], [, b]) => a.createdAt.getTime() - b.createdAt.getTime());
+
+      const toRemove = sorted.slice(0, this.sessions.size - this.MAX_SESSIONS);
+      toRemove.forEach(([id]) => this.sessions.delete(id));
+    }
+
+    return session;
+  }
+
+  get(sessionId: string): ChatSession | undefined {
+    return this.sessions.get(sessionId);
+  }
+
+  delete(sessionId: string): boolean {
+    return this.sessions.delete(sessionId);
+  }
+
+  private cleanupOldSessions(): void {
+    const now = Date.now();
+    const expiredIds: string[] = [];
+
+    for (const [id, session] of this.sessions.entries()) {
+      const age = now - session.updatedAt.getTime();
+      if (age > this.SESSION_TTL_MS) {
+        expiredIds.push(id);
+      }
+    }
+
+    expiredIds.forEach((id) => this.sessions.delete(id));
+  }
+
+  async send(sessionId: string, content: string): Promise<ChatSendResult> {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new GroqError(
+        GroqErrorType.MISSING_CONFIG,
+        `Chat session ${sessionId} not found`
+      );
+    }
+
+    const userMessage: GroqMessage = { role: "user", content };
+    session.messages.push(userMessage);
+
+    const messages = this.buildMessages(session);
+    const request = RequestBuilder.buildChatRequest(messages, {
+      model: session.model,
+    });
+
+    logger.debug("ChatSession", "Sending message", {
+      sessionId,
+      messageCount: session.messages.length,
+    });
+
+    const response = await groqHttpClient.chatCompletion(request);
+    const handled = ResponseHandler.handleResponse(response);
+
+    const assistantMessage: GroqMessage = {
+      role: "assistant",
+      content: handled.content,
+    };
+    session.messages.push(assistantMessage);
+    session.updatedAt = new Date();
+
+    return {
+      response: handled.content,
+      usage: handled.usage,
+      finishReason: handled.finishReason,
+    };
+  }
+
+  private buildMessages(session: ChatSession): GroqMessage[] {
+    const messages: GroqMessage[] = [];
+
+    if (session.systemInstruction) {
+      messages.push({ role: "system", content: session.systemInstruction });
+    }
+
+    messages.push(...session.messages);
+
+    return messages;
+  }
+}
+
+export const chatSessionManager = new ChatSessionManager();

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

@@ -0,0 +1,19 @@
+/**
+ * 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/application/use-cases/streaming.usecase.ts

@@ -0,0 +1,59 @@
+/**
+ * Streaming Use Case
+ * Handles streaming text generation
+ */
+
+import type { GroqGenerationConfig } from "../../domain/entities";
+import { streamChatCompletion } from "../../infrastructure/http";
+import { RequestBuilder } from "../../shared/request-builder";
+import { logger } from "../../shared/logger";
+
+export interface StreamingCallbacks {
+  onChunk?: (chunk: string) => void;
+  onComplete?: (fullContent: string) => void;
+  onError?: (error: Error) => void;
+}
+
+export interface StreamingOptions {
+  model?: string;
+  generationConfig?: GroqGenerationConfig;
+  callbacks?: StreamingCallbacks;
+}
+
+export async function* streamText(
+  prompt: string,
+  options: StreamingOptions = {}
+): AsyncGenerator<string> {
+  logger.debug("Streaming", "Starting", {
+    model: options.model,
+    promptLength: prompt.length,
+  });
+
+  const request = RequestBuilder.buildPromptRequest(prompt, options);
+  const config = {
+    apiKey: "", // Will be set by factory
+    baseUrl: "", // Will be set by factory
+  };
+
+  let fullContent = "";
+
+  try {
+    for await (const chunk of streamChatCompletion(request, config)) {
+      const content = chunk.choices[0]?.delta?.content;
+      if (content) {
+        fullContent += content;
+        options.callbacks?.onChunk?.(content);
+        yield content;
+      }
+    }
+
+    options.callbacks?.onComplete?.(fullContent);
+
+    logger.debug("Streaming", "Complete", {
+      totalLength: fullContent.length,
+    });
+  } catch (error) {
+    options.callbacks?.onError?.(error as Error);
+    throw error;
+  }
+}

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

@@ -0,0 +1,94 @@
+/**
+ * Structured Generation Use Case
+ * Generates structured JSON output from prompts
+ */
+
+import type { GroqGenerationConfig, GroqMessage } from "../../domain/entities";
+import { groqHttpClient } from "../../infrastructure/http";
+import { RequestBuilder } from "../../shared/request-builder";
+import { ResponseHandler } from "../../shared/response-handler";
+import { Timer, logger } from "../../shared/logger";
+import { GroqError, GroqErrorType } from "../../domain/entities/error.types";
+import { cleanJsonResponse } from "../../utils/content-mapper.util";
+
+export interface StructuredGenerationOptions<T> {
+  model?: string;
+  generationConfig?: GroqGenerationConfig;
+  schema?: Record<string, unknown>;
+  example?: T;
+}
+
+export async function generateStructured<T = Record<string, unknown>>(
+  prompt: string,
+  options: StructuredGenerationOptions<T> = {}
+): Promise<T> {
+  const timer = new Timer();
+
+  logger.debug("StructuredGeneration", "Called", {
+    model: options.model,
+    hasSchema: !!options.schema,
+    hasExample: !!options.example,
+  });
+
+  const systemPrompt = buildSystemPrompt(options.schema, options.example);
+  const request = RequestBuilder.buildSystemPromptRequest(systemPrompt, prompt, {
+    ...options,
+    defaultTemperature: 0.3,
+    defaultMaxTokens: 2048,
+  });
+
+  timer.startApiCall();
+  const response = await groqHttpClient.chatCompletion(request);
+  timer.endApiCall();
+
+  const result = timer.getResult();
+  logger.debug("StructuredGeneration", "API response", {
+    apiDuration: Timer.format(result.apiMs),
+  });
+
+  let content = ResponseHandler.extractContent(response);
+  content = cleanJsonResponse(content);
+
+  logger.debug("StructuredGeneration", "Parsing JSON");
+
+  try {
+    const parsed = JSON.parse(content) as T;
+
+    logger.debug("StructuredGeneration", "Complete", {
+      totalDuration: Timer.format(result.totalMs),
+      parsedKeys: Object.keys(parsed),
+    });
+
+    return parsed;
+  } catch (error) {
+    logger.error("StructuredGeneration", "JSON parse failed", {
+      error,
+      contentLength: content.length,
+    });
+
+    throw new GroqError(
+      GroqErrorType.UNKNOWN_ERROR,
+      `Failed to parse JSON: ${content}`,
+      error
+    );
+  }
+}
+
+function buildSystemPrompt<T>(
+  schema?: Record<string, unknown>,
+  example?: 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 (example) {
+    prompt += `\n\nExample response format:\n${JSON.stringify(example, null, 2)}`;
+  }
+
+  prompt += "\n\nIMPORTANT: Respond ONLY with valid JSON. No markdown, no code blocks.";
+
+  return prompt;
+}

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

@@ -0,0 +1,50 @@
+/**
+ * Text Generation Use Case
+ * Handles simple text generation from prompts
+ */
+
+import type { GroqGenerationConfig } from "../../domain/entities";
+import { groqHttpClient } from "../../infrastructure/http";
+import { RequestBuilder } from "../../shared/request-builder";
+import { ResponseHandler } from "../../shared/response-handler";
+import { Timer, logger } from "../../shared";
+
+export interface TextGenerationOptions {
+  model?: string;
+  generationConfig?: GroqGenerationConfig;
+}
+
+export async function generateText(
+  prompt: string,
+  options: TextGenerationOptions = {}
+): Promise<string> {
+  const timer = new Timer();
+
+  logger.debug("TextGeneration", "Called", {
+    model: options.model,
+    promptLength: prompt.length,
+  });
+
+  const request = RequestBuilder.buildPromptRequest(prompt, options);
+
+  logger.debug("TextGeneration", "Sending request", {
+    endpoint: "/v1/chat/completions",
+    model: request.model,
+  });
+
+  timer.startApiCall();
+  const response = await groqHttpClient.chatCompletion(request);
+  timer.endApiCall();
+
+  const result = timer.getResult();
+  ResponseHandler.logResponse(logger, response, result.apiMs);
+
+  const handled = ResponseHandler.handleResponse(response);
+
+  logger.debug("TextGeneration", "Complete", {
+    totalDuration: Timer.format(result.totalMs),
+    responseLength: handled.content.length,
+  });
+
+  return handled.content;
+}

package/src/index.ts

@@ -2,11 +2,18 @@
  * @umituz/react-native-ai-groq-provider
  * Groq text generation provider for React Native applications
  *
+ * DDD Architecture:
+ * - Domain: Core entities and types
+ * - Application: Use cases and business logic
+ * - Infrastructure: External services and HTTP clients
+ * - Presentation: React hooks and UI utilities
+ * - Shared: Common utilities
+ *
  * @author umituz
  * @license MIT
  */
 
-// Domain Types
+// Domain Layer
 export type {
   GroqConfig,
   GroqGenerationConfig,
@@ -42,32 +49,47 @@ export {
   type ModelInfo,
 } from "./domain/entities/models";
 
-// Services
-export { groqHttpClient } from "./infrastructure/services/GroqClient";
-export { textGeneration, chatGeneration } from "./infrastructure/services/TextGeneration";
-export { structuredText, structuredChat } from "./infrastructure/services/StructuredText";
-export { streaming, streamingChat } from "./infrastructure/services/Streaming";
+// Application Layer (Use Cases)
 export {
-  chatSessionService,
-  createChatSession,
-  sendChatMessage,
-  buildChatHistory,
-  trimChatHistory,
+  generateText,
+  generateStructured,
+  streamText,
+  chatSessionManager,
+  type TextGenerationOptions,
+  type StructuredGenerationOptions,
+  type StreamingCallbacks,
+  type StreamingOptions,
   type ChatSession,
-  type SendChatMessageOptions,
   type ChatSendResult,
-  type ChatHistoryMessage,
-} from "./infrastructure/services";
+} from "./application/use-cases";
 
-export type { StreamingCallbacks, StreamingOptions } from "./infrastructure/services/Streaming";
+// Infrastructure Layer
+export {
+  groqHttpClient,
+  streamChatCompletion,
+} from "./infrastructure/http";
 
-// React Hooks
-export { useGroq } from "./presentation/hooks/useGroq";
-export type { UseGroqOptions, UseGroqReturn } from "./presentation/hooks/useGroq";
+// Presentation Layer
+export {
+  useGroq,
+  type UseGroqOptions,
+  type UseGroqReturn,
+} from "./presentation";
 
-export { useOperationManager } from "./presentation/hooks/useOperationManager";
+// Shared Layer
+export {
+  logger,
+  LogLevel,
+  Timer,
+  RequestBuilder,
+  ResponseHandler,
+  type LogContext,
+  type TimerResult,
+  type RequestBuilderOptions,
+  type ResponseHandlerResult,
+} from "./shared";
 
-// Provider Configuration & Factory
+// Provider Factory
 export {
   ConfigBuilder,
   GenerationConfigBuilder,
@@ -75,11 +97,8 @@ export {
   initializeProvider,
   configureProvider,
   resetProvider,
-} from "./providers/ProviderFactory";
-
-export type {
-  ProviderConfig,
-  ProviderFactoryOptions,
+  type ProviderConfig,
+  type ProviderFactoryOptions,
 } from "./providers/ProviderFactory";
 
 // Utilities
@@ -91,21 +110,22 @@ export {
   promptToMessages,
   extractTextFromMessages,
   formatMessagesForDisplay,
-} from "./infrastructure/utils/content-mapper.util";
+  cleanJsonResponse,
+} from "./utils/content-mapper.util";
 
 export {
   getUserFriendlyError,
   isRetryableError,
   isAuthError,
   formatErrorForLogging,
-} from "./infrastructure/utils/error-mapper.util";
+} from "./utils/error-mapper.util";
 
 export {
   executeWithState,
   executeWithRetry,
   type AsyncStateSetters,
   type AsyncCallbacks,
-} from "./infrastructure/utils/async";
+} from "./utils/async";
 
 export {
   generateRandomId,
@@ -121,7 +141,7 @@ export {
   calculateRequestTimeout,
   calculateTransferRate,
   calculateAverage,
-} from "./infrastructure/utils/calculation.util";
+} from "./utils/calculation.util";
 
 export {
   telemetry,

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

@@ -0,0 +1,151 @@
+/**
+ * Groq HTTP Client
+ * Core HTTP client for Groq API - simplified and focused
+ */
+
+import type {
+  GroqConfig,
+  GroqChatRequest,
+  GroqChatResponse,
+  GroqChatChunk,
+} from "../../domain/entities";
+import { GroqError, GroqErrorType, mapHttpStatusToErrorType } from "../../domain/entities/error.types";
+import { logger } from "../../shared/logger";
+
+const DEFAULT_BASE_URL = "https://api.groq.com/openai/v1";
+const DEFAULT_TIMEOUT = 60000;
+
+class GroqHttpClient {
+  private config: GroqConfig | null = null;
+  private initialized = false;
+
+  initialize(config: GroqConfig): void {
+    const apiKey = config.apiKey?.trim();
+
+    logger.debug("GroqClient", "Initializing", {
+      hasApiKey: !!apiKey,
+      keyLength: apiKey?.length,
+      baseUrl: config.baseUrl || DEFAULT_BASE_URL,
+    });
+
+    if (!apiKey || apiKey.length < 10) {
+      throw new GroqError(
+        GroqErrorType.INVALID_API_KEY,
+        "API key is required and must be at least 10 characters"
+      );
+    }
+
+    this.config = {
+      apiKey,
+      baseUrl: config.baseUrl || DEFAULT_BASE_URL,
+      timeoutMs: config.timeoutMs || DEFAULT_TIMEOUT,
+      textModel: config.textModel,
+    };
+    this.initialized = true;
+
+    logger.debug("GroqClient", "Initialization complete", {
+      initialized: this.initialized,
+    });
+  }
+
+  isInitialized(): boolean {
+    return this.initialized && this.config !== null;
+  }
+
+  getConfig(): GroqConfig {
+    if (!this.config || !this.initialized) {
+      throw new GroqError(
+        GroqErrorType.MISSING_CONFIG,
+        "Client not initialized"
+      );
+    }
+    return this.config;
+  }
+
+  private async request<T>(endpoint: string, body: unknown): Promise<T> {
+    if (!this.config || !this.initialized) {
+      throw new GroqError(GroqErrorType.MISSING_CONFIG, "Client not initialized");
+    }
+
+    const url = `${this.config.baseUrl}${endpoint}`;
+    const timeout = this.config.timeoutMs || DEFAULT_TIMEOUT;
+
+    logger.debug("GroqClient", "API Request", {
+      endpoint,
+      timeout: `${timeout}ms`,
+    });
+
+    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 ${this.config.apiKey}`,
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        await this.handleErrorResponse(response);
+      }
+
+      return (await response.json()) as T;
+    } catch (error) {
+      throw this.handleRequestError(error);
+    }
+  }
+
+  private async 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 message
+    }
+
+    throw new GroqError(errorType, errorMessage);
+  }
+
+  private 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"
+    );
+  }
+
+  async chatCompletion(request: GroqChatRequest): Promise<GroqChatResponse> {
+    return this.request<GroqChatResponse>("/chat/completions", {
+      ...request,
+      stream: false,
+    });
+  }
+
+  reset(): void {
+    this.config = null;
+    this.initialized = false;
+  }
+}
+
+export const groqHttpClient = new GroqHttpClient();

package/src/infrastructure/http/index.ts

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