@umituz/web-ai-groq-provider 1.1.13 → 2.0.0

package/src/domains/chat/hooks/use-chat.hook.ts

@@ -1,259 +0,0 @@
-/**
- * useChat Hook
- * @description Main React hook for chat functionality with performance optimizations
- */
-
-import { useState, useCallback, useEffect, useRef } from "react";
-import type {
-  ChatMessage,
-  ChatConfig,
-} from "../entities";
-import type {
-  UseChatOptions,
-  UseChatReturn,
-} from "../interfaces";
-import { chatService } from "../services/chat.service";
-
-const MESSAGE_ID_PREFIX = "msg-";
-
-/**
- * Hook for chat functionality with AI integration and performance optimizations
- */
-export function useChat(options: UseChatOptions): UseChatReturn {
-  const {
-    conversationId,
-    storage,
-    config,
-    autoSave = true,
-    onMessageSent: _onMessageSent,
-    onAIResponse: _onAIResponse,
-    onError: _onError,
-  } = options;
-
-  const [messages, setMessages] = useState<ChatMessage[]>([]);
-  const [isLoading, setIsLoading] = useState(false);
-  const [isTyping, setIsTyping] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-
-  // Refs for deduplication and callback tracking
-  const pendingMessageRef = useRef<string | null>(null);
-  const optionsRef = useRef(options);
-  optionsRef.current = options;
-
-  // Initialize chat service config
-  useEffect(() => {
-    if (config) {
-      chatService.initialize(config);
-    }
-  }, [config]);
-
-  // Cleanup on unmount
-  useEffect(() => {
-    return () => {
-      pendingMessageRef.current = null;
-    };
-  }, []);
-
-  // Load messages from storage on mount
-  useEffect(() => {
-    if (!storage) return;
-
-    const loadMessages = async () => {
-      try {
-        const loaded = await storage.getMessages(conversationId);
-        setMessages(loaded);
-      } catch (_err) {
-        // Silently fail - errors are handled through onError callback if needed
-      }
-    };
-
-    void loadMessages();
-  }, [conversationId, storage]);
-
-  // Save message to storage (stable reference)
-  const saveToStorage = useCallback(
-    async (message: ChatMessage) => {
-      if (!autoSave || !storage) return;
-
-      try {
-        await storage.saveMessage(conversationId, message);
-      } catch (_err) {
-        // Silently fail - errors are handled through onError callback if needed
-      }
-    },
-    [conversationId, storage, autoSave]
-  );
-
-  // Batch save messages to storage (reserved for future use)
-  const _saveMessagesToStorage = useCallback(
-    async (messagesToSave: ChatMessage[]) => {
-      if (!autoSave || !storage || messagesToSave.length === 0) return;
-
-      try {
-        // Try batch save if supported
-        if ('saveMessages' in storage) {
-          await (storage as unknown as { saveMessages: (id: string, msgs: ChatMessage[]) => Promise<void> }).saveMessages(conversationId, messagesToSave);
-        } else {
-          // Fallback to individual saves in parallel
-          await Promise.all(
-            messagesToSave.map(msg => storage.saveMessage(conversationId, msg))
-          );
-        }
-      } catch (_err) {
-        // Silently fail
-      }
-    },
-    [conversationId, storage, autoSave]
-  );
-
-  // Send message with deduplication and functional updates
-  const sendMessage = useCallback(
-    async (text: string, type?: ChatMessage["type"]): Promise<void> => {
-      if (!text.trim() || isLoading) return;
-
-      // Prevent duplicate messages
-      if (pendingMessageRef.current === text) {
-        return;
-      }
-
-      pendingMessageRef.current = text;
-      setIsLoading(true);
-      setError(null);
-
-      // Get latest callbacks from ref
-      const currentOptions = optionsRef.current;
-
-      try {
-        // Create user message
-        const userMessage: ChatMessage = {
-          id: `${MESSAGE_ID_PREFIX}${Date.now()}-user`,
-          sender: "user",
-          content: text,
-          timestamp: new Date().toISOString(),
-          type: type || "text",
-        };
-
-        // Use functional update to avoid stale closure
-        setMessages(prev => {
-          const updated = [...prev, userMessage];
-          saveToStorage(userMessage);
-          currentOptions.onMessageSent?.(userMessage);
-          return updated;
-        });
-
-        // Generate AI response
-        setIsTyping(true);
-
-        // Get current messages for context
-        const contextForAI = messages; // Use closure messages, not functional update
-
-        const aiResponse = await chatService.generateAIResponse(
-          conversationId,
-          text,
-          contextForAI
-        );
-
-        // Use functional update for AI response
-        setMessages(prev => {
-          const updated = [...prev, aiResponse];
-          saveToStorage(aiResponse);
-          currentOptions.onAIResponse?.(aiResponse);
-          return updated;
-        });
-      } catch (err) {
-        const errorMessage =
-          err instanceof Error ? err.message : "Failed to send message";
-        setError(errorMessage);
-        currentOptions.onError?.(errorMessage);
-      } finally {
-        setIsLoading(false);
-        setIsTyping(false);
-        pendingMessageRef.current = null;
-      }
-    },
-    [conversationId, isLoading, saveToStorage, messages]
-  );
-
-  // Regenerate last AI response with functional updates
-  const regenerate = useCallback(async (): Promise<void> => {
-    // Use functional update to get latest messages
-    setMessages(currentMessages => {
-      if (currentMessages.length === 0 || isLoading) {
-        return currentMessages;
-      }
-
-      const lastUserMessage = [...currentMessages]
-        .reverse()
-        .find((m) => m.sender === "user");
-
-      if (!lastUserMessage) return currentMessages;
-
-      // Async operation - need to handle differently
-      setIsLoading(true);
-      setError(null);
-
-      const currentOptions = optionsRef.current;
-
-      // Remove last AI message if exists
-      const messagesWithoutAI = currentMessages.filter(
-        (m, i) => !(i === currentMessages.length - 1 && m.sender === "assistant")
-      );
-
-      // Trigger async update
-      (async () => {
-        try {
-          // Generate new response
-          setIsTyping(true);
-          const aiResponse = await chatService.generateAIResponse(
-            conversationId,
-            lastUserMessage.content,
-            messagesWithoutAI.slice(0, -1)
-          );
-
-          // Update messages with new response
-          setMessages(prev => {
-            const lastIsAI = prev.length > 0 && prev[prev.length - 1].sender === "assistant";
-            const base = lastIsAI ? prev.slice(0, -1) : prev;
-            return [...base, aiResponse];
-          });
-
-          // Save to storage
-          await saveToStorage(aiResponse);
-          currentOptions.onAIResponse?.(aiResponse);
-        } catch (err) {
-          const errorMessage =
-            err instanceof Error ? err.message : "Failed to regenerate";
-          setError(errorMessage);
-          currentOptions.onError?.(errorMessage);
-        } finally {
-          setIsLoading(false);
-          setIsTyping(false);
-        }
-      })();
-
-      return messagesWithoutAI;
-    });
-  }, [conversationId, isLoading, saveToStorage]);
-
-  // Clear all messages
-  const clearMessages = useCallback(() => {
-    setMessages([]);
-    setError(null);
-  }, []);
-
-  // Update configuration
-  const updateConfig = useCallback((newConfig: Partial<ChatConfig>) => {
-    chatService.updateConfig(newConfig);
-  }, []);
-
-  return {
-    messages,
-    isLoading,
-    error,
-    isTyping,
-    sendMessage,
-    regenerate,
-    clearMessages,
-    updateConfig,
-  };
-}

package/src/domains/chat/index.ts

@@ -1,32 +0,0 @@
-/**
- * Chat Domain
- * @description Chat functionality with AI integration
- * Subpath: @umituz/web-ai-groq-provider/chat
- */
-
-// Entities
-export type {
-  ChatMessageSender,
-  ChatMessageType,
-  ChatMessage,
-  ChatConversation,
-  SendMessageInput,
-  SendMessageResult,
-  ChatConfig,
-} from "./entities";
-
-export type { IChatStorage } from "./entities";
-
-// Interfaces
-export type {
-  IChatService,
-  UseChatOptions,
-  UseChatReturn,
-  IMessageFormatter,
-} from "./interfaces";
-
-// Services
-export { chatService, messageFormatter } from "./services";
-
-// Hooks
-export { useChat } from "./hooks";

package/src/domains/chat/interfaces/chat.interface.ts

@@ -1,80 +0,0 @@
-/**
- * Chat Service Interfaces
- * @description Contracts for chat functionality
- */
-
-import type {
-  ChatMessage,
-  ChatConversation,
-  SendMessageInput,
-  SendMessageResult,
-  ChatConfig,
-  IChatStorage,
-} from "../entities";
-import type { GroqMessage } from "../../groq/entities";
-
-/**
- * Chat service interface
- */
-export interface IChatService {
-  /** Send message and get AI response */
-  sendMessage(input: SendMessageInput): Promise<SendMessageResult>;
-  /** Get conversation history */
-  getConversation(conversationId: string): Promise<ChatConversation | null>;
-  /** Get all conversations */
-  getConversations(): Promise<ChatConversation[]>;
-  /** Generate AI response only */
-  generateAIResponse(companionId: string, userMessage: string, context?: ChatMessage[]): Promise<ChatMessage>;
-}
-
-/**
- * Chat hook options
- */
-export interface UseChatOptions {
-  /** Conversation identifier */
-  readonly conversationId: string;
-  /** Storage implementation */
-  readonly storage?: IChatStorage;
-  /** Chat configuration */
-  readonly config?: ChatConfig;
-  /** Auto-save messages */
-  readonly autoSave?: boolean;
-  /** Callback on message sent */
-  readonly onMessageSent?: (message: ChatMessage) => void;
-  /** Callback on AI response */
-  readonly onAIResponse?: (message: ChatMessage) => void;
-  /** Callback on error */
-  readonly onError?: (error: string) => void;
-}
-
-/**
- * Chat hook return value
- */
-export interface UseChatReturn {
-  /** Messages in conversation */
-  readonly messages: ChatMessage[];
-  /** Loading state */
-  readonly isLoading: boolean;
-  /** Error message */
-  readonly error: string | null;
-  /** Is AI typing */
-  readonly isTyping: boolean;
-  /** Send message */
-  sendMessage: (text: string, type?: ChatMessage["type"]) => Promise<void>;
-  /** Regenerate last AI response */
-  regenerate: () => Promise<void>;
-  /** Clear messages */
-  clearMessages: () => void;
-  /** Update configuration */
-  updateConfig: (config: Partial<ChatConfig>) => void;
-}
-
-/**
- * Message formatter for Groq
- */
-export interface IMessageFormatter {
-  /** Format chat messages to Groq format */
-  toGroqMessages(messages: ChatMessage[], systemPrompt?: string): GroqMessage[];
-  /** Format Groq response to chat message */
-  toChatMessage(content: string, sender: ChatMessage["sender"]): ChatMessage;
-}

package/src/domains/chat/interfaces/index.ts

@@ -1,10 +0,0 @@
-/**
- * Chat Interfaces
- */
-
-export type {
-  IChatService,
-  UseChatOptions,
-  UseChatReturn,
-  IMessageFormatter,
-} from "./chat.interface";

package/src/domains/chat/services/chat.service.ts

@@ -1,195 +0,0 @@
-/**
- * Chat Service
- * @description Core chat logic with AI integration and performance optimizations
- */
-
-import type {
-  IChatService,
-} from "../interfaces";
-import type {
-  ChatMessage,
-  ChatConversation,
-  SendMessageInput,
-  SendMessageResult,
-  ChatConfig,
-} from "../entities";
-import { textGenerationService } from "../../groq/services";
-import { messageFormatter } from "../utils/message-formatter";
-import { DEFAULT_MODELS } from "../../groq/constants";
-import { cacheManager } from "../../groq/utils/cache-manager.util";
-
-const DEFAULT_CONFIG: ChatConfig = {
-  temperature: 0.8,
-  maxTokens: 500,
-  includeTimestamp: true,
-  language: "tr",
-};
-
-class ChatService implements IChatService {
-  private config: ChatConfig = DEFAULT_CONFIG;
-  private systemPromptCache = new Map<string, string>();
-  private readonly PROMPT_CACHE_KEY_PREFIX = "system-prompt";
-
-  initialize(config: ChatConfig): void {
-    this.config = { ...DEFAULT_CONFIG, ...config };
-    // Clear system prompt cache when config changes
-    this.clearSystemPromptCache();
-  }
-
-  updateConfig(config: Partial<ChatConfig>): void {
-    this.config = { ...this.config, ...config };
-    // Clear system prompt cache when config changes
-    this.clearSystemPromptCache();
-  }
-
-  async sendMessage(input: SendMessageInput): Promise<SendMessageResult> {
-    // Create user message with all properties
-    const userMessage: ChatMessage = {
-      ...messageFormatter.toChatMessage(input.text, "user"),
-      type: input.type || "text",
-      ...(input.imageUrl && { imageUrl: input.imageUrl }),
-    };
-
-    // Generate AI response
-    const aiResponse = await this.generateAIResponse(
-      input.companionId,
-      input.text,
-      []
-    );
-
-    return {
-      userMessage,
-      aiResponse,
-    };
-  }
-
-  async getConversation(_conversationId: string): Promise<ChatConversation | null> {
-    // This would fetch from storage
-    // For now, return null - storage is handled by application
-    return null;
-  }
-
-  async getConversations(): Promise<ChatConversation[]> {
-    // This would fetch from storage
-    return [];
-  }
-
-  async generateAIResponse(
-    companionId: string,
-    userMessage: string,
-    context: ChatMessage[] = []
-  ): Promise<ChatMessage> {
-    try {
-      // Build system prompt from config (with caching)
-      const systemPrompt = this.buildSystemPrompt();
-
-      // Format messages for Groq
-      const groqMessages = messageFormatter.toGroqMessages(
-        context,
-        systemPrompt
-      );
-
-      // Add current user message
-      groqMessages.push({
-        role: "user",
-        content: userMessage,
-      });
-
-      // Check cache for response
-      const cacheKey = cacheManager.generateKey({
-        companionId,
-        userMessage,
-        context: context.map(m => ({ sender: m.sender, content: m.content })),
-        config: {
-          temperature: this.config.temperature,
-          maxTokens: this.config.maxTokens,
-        },
-      });
-
-      const cachedResponse = cacheManager.get<string>(cacheKey);
-      const response = cachedResponse ||
-        await textGenerationService.generateChatCompletion(
-          groqMessages,
-          {
-            model: DEFAULT_MODELS.TEXT,
-            generationConfig: {
-              temperature: this.config.temperature,
-              maxTokens: this.config.maxTokens,
-            },
-          }
-        );
-
-      // Cache the response if it wasn't cached
-      if (!cachedResponse) {
-        cacheManager.set(cacheKey, response);
-      }
-
-      // Format response as chat message
-      const aiMessage: ChatMessage = {
-        ...messageFormatter.toChatMessage(response, "assistant"),
-        metadata: {
-          companionId,
-          model: DEFAULT_MODELS.TEXT,
-          cached: !!cachedResponse,
-        },
-      };
-
-      return aiMessage;
-    } catch (_error) {
-      // Fallback response on error
-      return messageFormatter.toChatMessage(
-        "Şimdi biraz meşgulüm, ama seni duyuyorum! 💫",
-        "assistant"
-      );
-    }
-  }
-
-  private buildSystemPrompt(): string {
-    const language = this.config.language || "tr";
-    const customPrompt = this.config.systemPrompt;
-
-    // Generate cache key
-    const cacheKey = `${this.PROMPT_CACHE_KEY_PREFIX}-${language}-${customPrompt?.length || 0}`;
-
-    // Check cache
-    if (this.systemPromptCache.has(cacheKey)) {
-      return this.systemPromptCache.get(cacheKey)!;
-    }
-
-    // Build prompt
-    const basePrompt = customPrompt || this.getDefaultPrompt(language);
-
-    // Cache it
-    this.systemPromptCache.set(cacheKey, basePrompt);
-
-    return basePrompt;
-  }
-
-  private clearSystemPromptCache(): void {
-    this.systemPromptCache.clear();
-  }
-
-  /**
-   * Clear all cached data (system prompts and response cache)
-   */
-  clearCache(): void {
-    this.clearSystemPromptCache();
-    // Note: Response cache is managed by textGenerationService
-    // Export cache clearing function from there if needed
-  }
-
-  private getDefaultPrompt(language: string): string {
-    if (language === "tr") {
-      return `Sen samimi, eğlenceli ve ilgi çekici bir AI companionsın. Türkçe konuşuyorsun.
-Kullanıcıyla doğal, rahat ve arkadaşça bir sohbet tarzı benimseyerek iletişim kur.
-Yavaş yazma stilini kullan ama abartma. Emoji kullanabilirsin ama çok da abartma.
-Kısa ve öz cevaplar ver.`;
-    }
-
-    return `You are a friendly, engaging AI companion. Be natural, casual, and warm.
-Keep responses concise and conversational. Use emojis sparingly.`;
-  }
-}
-
-export const chatService = new ChatService();
-export { messageFormatter };

package/src/domains/chat/services/index.ts

@@ -1,5 +0,0 @@
-/**
- * Chat Services
- */
-
-export { chatService, messageFormatter } from "./chat.service";

package/src/domains/chat/utils/message-formatter.ts

@@ -1,49 +0,0 @@
-/**
- * Message Formatter Utility
- * @description Convert between chat messages and Groq format
- */
-
-import type { IMessageFormatter } from "../interfaces";
-import type { ChatMessage } from "../entities";
-import type { GroqMessage } from "../../groq/entities";
-
-const MESSAGE_ID_PREFIX = "msg-";
-
-class MessageFormatter implements IMessageFormatter {
-  toGroqMessages(messages: ChatMessage[], systemPrompt?: string): GroqMessage[] {
-    const groqMessages: GroqMessage[] = [];
-
-    // Add system prompt first
-    if (systemPrompt) {
-      groqMessages.push({
-        role: "system",
-        content: systemPrompt,
-      });
-    }
-
-    // Convert chat messages to Groq format
-    for (const message of messages) {
-      // Skip system messages from context
-      if (message.sender === "system") continue;
-
-      groqMessages.push({
-        role: message.sender === "user" ? "user" : "assistant",
-        content: message.content,
-      });
-    }
-
-    return groqMessages;
-  }
-
-  toChatMessage(content: string, sender: ChatMessage["sender"]): ChatMessage {
-    return {
-      id: `${MESSAGE_ID_PREFIX}${Date.now()}-${Math.random().toString(36).substring(2, 11)}`,
-      sender,
-      content: content.trim(),
-      timestamp: new Date().toISOString(),
-      type: "text",
-    };
-  }
-}
-
-export const messageFormatter = new MessageFormatter();

package/src/domains/groq/constants/error.constants.ts

@@ -1,46 +0,0 @@
-/**
- * Error Type Constants
- * @description Error types and mappings for Groq API
- */
-
-/**
- * Error types enum
- */
-export enum GroqErrorType {
-  INVALID_API_KEY = "INVALID_API_KEY",
-  MISSING_CONFIG = "MISSING_CONFIG",
-  NETWORK_ERROR = "NETWORK_ERROR",
-  ABORT_ERROR = "ABORT_ERROR",
-  RATE_LIMIT_ERROR = "RATE_LIMIT_ERROR",
-  SERVER_ERROR = "SERVER_ERROR",
-  UNKNOWN_ERROR = "UNKNOWN_ERROR",
-}
-
-/**
- * Map HTTP status to error type
- */
-export function mapHttpStatusToErrorType(status: number): GroqErrorType {
-  if (status === 401 || status === 403) return GroqErrorType.INVALID_API_KEY;
-  if (status === 429) return GroqErrorType.RATE_LIMIT_ERROR;
-  if (status >= 500) return GroqErrorType.SERVER_ERROR;
-  if (status >= 400) return GroqErrorType.INVALID_API_KEY;
-  return GroqErrorType.UNKNOWN_ERROR;
-}
-
-/**
- * Check if error is retryable
- */
-export function isRetryableError(errorType: GroqErrorType): boolean {
-  return [
-    GroqErrorType.NETWORK_ERROR,
-    GroqErrorType.RATE_LIMIT_ERROR,
-    GroqErrorType.SERVER_ERROR,
-  ].includes(errorType);
-}
-
-/**
- * Check if error is auth-related
- */
-export function isAuthError(errorType: GroqErrorType): boolean {
-  return errorType === GroqErrorType.INVALID_API_KEY;
-}