@umituz/web-ai-groq-provider 1.0.1 → 1.1.0

package/package.json

@@ -1,15 +1,14 @@
 {
   "name": "@umituz/web-ai-groq-provider",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Groq AI text generation provider for React web applications",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "sideEffects": false,
   "exports": {
     ".": "./src/index.ts",
-    "./domain": "./src/domain/index.ts",
-    "./services": "./src/infrastructure/services/index.ts",
-    "./hooks": "./src/presentation/hooks/index.ts",
+    "./groq": "./src/domains/groq/index.ts",
+    "./chat": "./src/domains/chat/index.ts",
     "./package.json": "./package.json"
   },
   "scripts": {

package/src/domains/chat/entities/chat.entities.ts

@@ -0,0 +1,113 @@
+/**
+ * Chat Domain Entities
+ * @description Core chat message and conversation types
+ */
+
+/**
+ * Message sender type
+ */
+export type ChatMessageSender = "user" | "assistant" | "system";
+
+/**
+ * Message content types
+ */
+export type ChatMessageType = "text" | "image" | "audio" | "sticker";
+
+/**
+ * Chat message structure
+ */
+export interface ChatMessage {
+  /** Unique message identifier */
+  readonly id: string;
+  /** Sender of the message */
+  readonly sender: ChatMessageSender;
+  /** Message content */
+  readonly content: string;
+  /** Timestamp in ISO format */
+  readonly timestamp: string;
+  /** Message type */
+  readonly type?: ChatMessageType;
+  /** Image URL for image messages */
+  readonly imageUrl?: string;
+  /** Reaction emoji */
+  readonly reaction?: string;
+  /** Metadata */
+  readonly metadata?: Record<string, unknown>;
+}
+
+/**
+ * Conversation/session metadata
+ */
+export interface ChatConversation {
+  /** Unique conversation identifier */
+  readonly id: string;
+  /** Companion/character identifier */
+  readonly companionId: string;
+  /** Companion name */
+  readonly companionName: string;
+  /** Last message */
+  readonly lastMessage?: ChatMessage;
+  /** Message count */
+  readonly messageCount: number;
+  /** Updated timestamp */
+  readonly updatedAt: string;
+  /** Is pinned */
+  readonly pinned?: boolean;
+  /** Is archived */
+  readonly archived?: boolean;
+}
+
+/**
+ * Send message input
+ */
+export interface SendMessageInput {
+  /** Companion identifier */
+  readonly companionId: string;
+  /** Message text */
+  readonly text: string;
+  /** Message type */
+  readonly type?: ChatMessageType;
+  /** Image URL */
+  readonly imageUrl?: string;
+}
+
+/**
+ * Send message result
+ */
+export interface SendMessageResult {
+  /** User message */
+  readonly userMessage: ChatMessage;
+  /** AI response (if generated) */
+  readonly aiResponse?: ChatMessage;
+}
+
+/**
+ * Chat configuration
+ */
+export interface ChatConfig {
+  /** System prompt for AI personality */
+  readonly systemPrompt?: string;
+  /** Temperature for randomness */
+  readonly temperature?: number;
+  /** Maximum tokens */
+  readonly maxTokens?: number;
+  /** Include timestamp in messages */
+  readonly includeTimestamp?: boolean;
+  /** Language code (e.g., 'tr', 'en') */
+  readonly language?: string;
+}
+
+/**
+ * Storage interface for persisting messages
+ * Implementations should be provided by the application
+ */
+export interface IChatStorage {
+  /** Save message to storage */
+  saveMessage(conversationId: string, message: ChatMessage): Promise<void>;
+  /** Get messages for conversation */
+  getMessages(conversationId: string): Promise<ChatMessage[]>;
+  /** Update message */
+  updateMessage(messageId: string, updates: Partial<ChatMessage>): Promise<void>;
+  /** Delete message */
+  deleteMessage(messageId: string): Promise<void>;
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Chat Entities
+ */
+
+export type {
+  ChatMessageSender,
+  ChatMessageType,
+  ChatMessage,
+  ChatConversation,
+  SendMessageInput,
+  SendMessageResult,
+  ChatConfig,
+  IChatStorage,
+} from "./chat.entities";

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

@@ -0,0 +1,5 @@
+/**
+ * Chat Hooks
+ */
+
+export { useChat } from "./use-chat.hook";

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

@@ -0,0 +1,231 @@
+/**
+ * useChat Hook
+ * @description Main React hook for chat functionality
+ */
+
+import { useState, useCallback, useEffect, useMemo } from "react";
+import type {
+  ChatMessage,
+  ChatConfig,
+  IChatStorage,
+} from "../../entities";
+import type {
+  UseChatOptions,
+  UseChatReturn,
+} from "../../interfaces";
+import { chatService } from "../services/chat.service";
+
+const isDevelopment =
+  typeof process !== "undefined" && process.env?.NODE_ENV === "development";
+
+/**
+ * Hook for chat functionality with AI integration
+ */
+export function useChat(options: UseChatOptions): UseChatReturn {
+  const {
+    conversationId,
+    storage,
+    config,
+    autoSave = true,
+    onMessageSent,
+    onAIResponse,
+    onError,
+  } = options;
+
+  const [messages, setMessages] = useState<ChatMessage[]>([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [isTyping, setIsTyping] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  // Initialize chat service config
+  useEffect(() => {
+    if (config) {
+      chatService.initialize(config);
+    }
+  }, [config]);
+
+  // Load messages from storage on mount
+  useEffect(() => {
+    if (!storage) return;
+
+    const loadMessages = async () => {
+      try {
+        const loaded = await storage.getMessages(conversationId);
+        setMessages(loaded);
+
+        if (isDevelopment) {
+          console.log("[useChat] Loaded messages:", loaded.length);
+        }
+      } catch (err) {
+        console.error("[useChat] Failed to load messages:", err);
+      }
+    };
+
+    void loadMessages();
+  }, [conversationId, storage]);
+
+  // Save message to storage
+  const saveToStorage = useCallback(
+    async (message: ChatMessage) => {
+      if (!autoSave || !storage) return;
+
+      try {
+        await storage.saveMessage(conversationId, message);
+
+        if (isDevelopment) {
+          console.log("[useChat] Message saved to storage");
+        }
+      } catch (err) {
+        console.error("[useChat] Failed to save message:", err);
+      }
+    },
+    [conversationId, storage, autoSave]
+  );
+
+  // Send message
+  const sendMessage = useCallback(
+    async (text: string, type?: ChatMessage["type"]): Promise<void> => {
+      if (!text.trim() || isLoading) return;
+
+      setIsLoading(true);
+      setError(null);
+
+      try {
+        if (isDevelopment) {
+          console.log("[useChat] Sending message:", { text, type });
+        }
+
+        // Generate AI response
+        setIsTyping(true);
+        const aiResponse = await chatService.generateAIResponse(
+          conversationId,
+          text,
+          messages
+        );
+
+        // Create user message
+        const userMessage: ChatMessage = {
+          id: `msg-${Date.now()}-user`,
+          sender: "user",
+          content: text,
+          timestamp: new Date().toISOString(),
+          type: type || "text",
+        };
+
+        // Update messages
+        const newMessages = [...messages, userMessage, aiResponse];
+        setMessages(newMessages);
+
+        // Save to storage
+        await saveToStorage(userMessage);
+        await saveToStorage(aiResponse);
+
+        // Callbacks
+        onMessageSent?.(userMessage);
+        onAIResponse?.(aiResponse);
+
+        if (isDevelopment) {
+          console.log("[useChat] Message sent, AI response received");
+        }
+      } catch (err) {
+        const errorMessage =
+          err instanceof Error ? err.message : "Failed to send message";
+        setError(errorMessage);
+        onError?.(errorMessage);
+
+        if (isDevelopment) {
+          console.error("[useChat] Error sending message:", err);
+        }
+      } finally {
+        setIsLoading(false);
+        setIsTyping(false);
+      }
+    },
+    [
+      conversationId,
+      messages,
+      isLoading,
+      saveToStorage,
+      onMessageSent,
+      onAIResponse,
+      onError,
+    ]
+  );
+
+  // Regenerate last AI response
+  const regenerate = useCallback(async (): Promise<void> => {
+    if (messages.length === 0 || isLoading) return;
+
+    const lastUserMessage = [...messages]
+      .reverse()
+      .find((m) => m.sender === "user");
+
+    if (!lastUserMessage) return;
+
+    setIsLoading(true);
+    setError(null);
+
+    try {
+      // Remove last AI message if exists
+      const messagesWithoutAI = messages.filter(
+        (m, i) => !(i === messages.length - 1 && m.sender === "assistant")
+      );
+
+      setMessages(messagesWithoutAI);
+
+      // Generate new response
+      setIsTyping(true);
+      const aiResponse = await chatService.generateAIResponse(
+        conversationId,
+        lastUserMessage.content,
+        messagesWithoutAI.slice(0, -1)
+      );
+
+      // Update messages
+      const newMessages = [...messagesWithoutAI, aiResponse];
+      setMessages(newMessages);
+
+      // Save to storage
+      await saveToStorage(aiResponse);
+
+      onAIResponse?.(aiResponse);
+    } catch (err) {
+      const errorMessage =
+        err instanceof Error ? err.message : "Failed to regenerate";
+      setError(errorMessage);
+      onError?.(errorMessage);
+    } finally {
+      setIsLoading(false);
+      setIsTyping(false);
+    }
+  }, [
+    conversationId,
+    messages,
+    isLoading,
+    saveToStorage,
+    onAIResponse,
+    onError,
+  ]);
+
+  // 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

@@ -0,0 +1,32 @@
+/**
+ * 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

@@ -0,0 +1,79 @@
+/**
+ * Chat Service Interfaces
+ * @description Contracts for chat functionality
+ */
+
+import type {
+  ChatMessage,
+  ChatConversation,
+  SendMessageInput,
+  SendMessageResult,
+  ChatConfig,
+} from "../entities";
+import type { GroqMessage } from "../../groq/interfaces";
+
+/**
+ * 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?: import("../entities").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

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

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

@@ -0,0 +1,143 @@
+/**
+ * Chat Service
+ * @description Core chat logic with AI integration
+ */
+
+import type {
+  IChatService,
+  IMessageFormatter,
+} from "../../interfaces";
+import type {
+  ChatMessage,
+  ChatConversation,
+  SendMessageInput,
+  SendMessageResult,
+  ChatConfig,
+} from "../../entities";
+import { textGenerationService } from "../../../groq/services/text-generation.service";
+import { messageFormatter } from "../utils/message-formatter";
+
+const DEFAULT_CONFIG: ChatConfig = {
+  temperature: 0.8,
+  maxTokens: 500,
+  includeTimestamp: true,
+  language: "tr",
+};
+
+class ChatService implements IChatService {
+  private config: ChatConfig = DEFAULT_CONFIG;
+
+  initialize(config: ChatConfig): void {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+
+  updateConfig(config: Partial<ChatConfig>): void {
+    this.config = { ...this.config, ...config };
+  }
+
+  async sendMessage(input: SendMessageInput): Promise<SendMessageResult> {
+    // Create user message
+    const userMessage = messageFormatter.toChatMessage(input.text, "user");
+    userMessage.type = input.type || "text";
+    if (input.imageUrl) {
+      userMessage.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
+      const systemPrompt = this.buildSystemPrompt();
+
+      // Format messages for Groq
+      const groqMessages = messageFormatter.toGroqMessages(
+        context,
+        systemPrompt
+      );
+
+      // Add current user message
+      groqMessages.push({
+        role: "user",
+        content: userMessage,
+      });
+
+      // Generate response
+      const response = await textGenerationService.generateChatCompletion(
+        groqMessages,
+        {
+          model: "llama-3.3-70b-versatile",
+          generationConfig: {
+            temperature: this.config.temperature,
+            maxTokens: this.config.maxTokens,
+          },
+        }
+      );
+
+      // Format response as chat message
+      const aiMessage = messageFormatter.toChatMessage(response, "assistant");
+      aiMessage.metadata = {
+        companionId,
+        model: "llama-3.3-70b-versatile",
+      };
+
+      return aiMessage;
+    } catch (error) {
+      console.error("[ChatService] Error generating AI response:", error);
+
+      // Fallback response
+      return messageFormatter.toChatMessage(
+        "Şimdi biraz meşgulüm, ama seni duyuyorum! 💫",
+        "assistant"
+      );
+    }
+  }
+
+  private buildSystemPrompt(): string {
+    const language = this.config.language || "tr";
+    const basePrompt = this.config.systemPrompt || this.getDefaultPrompt(language);
+
+    return basePrompt;
+  }
+
+  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

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

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

@@ -0,0 +1,47 @@
+/**
+ * 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/interfaces";
+
+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: `msg-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      sender,
+      content: content.trim(),
+      timestamp: new Date().toISOString(),
+      type: "text",
+    };
+  }
+}
+
+export const messageFormatter = new MessageFormatter();

package/src/domains/groq/entities/chat.entities.ts

@@ -0,0 +1,113 @@
+/**
+ * Chat Domain Entities
+ * @description Core chat message and conversation types
+ */
+
+/**
+ * Message sender type
+ */
+export type ChatMessageSender = "user" | "assistant" | "system";
+
+/**
+ * Message content types
+ */
+export type ChatMessageType = "text" | "image" | "audio" | "sticker";
+
+/**
+ * Chat message structure
+ */
+export interface ChatMessage {
+  /** Unique message identifier */
+  readonly id: string;
+  /** Sender of the message */
+  readonly sender: ChatMessageSender;
+  /** Message content */
+  readonly content: string;
+  /** Timestamp in ISO format */
+  readonly timestamp: string;
+  /** Message type */
+  readonly type?: ChatMessageType;
+  /** Image URL for image messages */
+  readonly imageUrl?: string;
+  /** Reaction emoji */
+  readonly reaction?: string;
+  /** Metadata */
+  readonly metadata?: Record<string, unknown>;
+}
+
+/**
+ * Conversation/session metadata
+ */
+export interface ChatConversation {
+  /** Unique conversation identifier */
+  readonly id: string;
+  /** Companion/character identifier */
+  readonly companionId: string;
+  /** Companion name */
+  readonly companionName: string;
+  /** Last message */
+  readonly lastMessage?: ChatMessage;
+  /** Message count */
+  readonly messageCount: number;
+  /** Updated timestamp */
+  readonly updatedAt: string;
+  /** Is pinned */
+  readonly pinned?: boolean;
+  /** Is archived */
+  readonly archived?: boolean;
+}
+
+/**
+ * Send message input
+ */
+export interface SendMessageInput {
+  /** Companion identifier */
+  readonly companionId: string;
+  /** Message text */
+  readonly text: string;
+  /** Message type */
+  readonly type?: ChatMessageType;
+  /** Image URL */
+  readonly imageUrl?: string;
+}
+
+/**
+ * Send message result
+ */
+export interface SendMessageResult {
+  /** User message */
+  readonly userMessage: ChatMessage;
+  /** AI response (if generated) */
+  readonly aiResponse?: ChatMessage;
+}
+
+/**
+ * Chat configuration
+ */
+export interface ChatConfig {
+  /** System prompt for AI personality */
+  readonly systemPrompt?: string;
+  /** Temperature for randomness */
+  readonly temperature?: number;
+  /** Maximum tokens */
+  readonly maxTokens?: number;
+  /** Include timestamp in messages */
+  readonly includeTimestamp?: boolean;
+  /** Language code (e.g., 'tr', 'en') */
+  readonly language?: string;
+}
+
+/**
+ * Storage interface for persisting messages
+ * Implementations should be provided by the application
+ */
+export interface ChatStorage {
+  /** Save message to storage */
+  saveMessage(conversationId: string, message: ChatMessage): Promise<void>;
+  /** Get messages for conversation */
+  getMessages(conversationId: string): Promise<ChatMessage[]>;
+  /** Update message */
+  updateMessage(messageId: string, updates: Partial<ChatMessage>): Promise<void>;
+  /** Delete message */
+  deleteMessage(messageId: string): Promise<void>;
+}

package/src/domains/groq/index.ts

@@ -0,0 +1,72 @@
+/**
+ * Groq Domain
+ * @description Groq API client and text generation
+ * Subpath: @umituz/web-ai-groq-provider/groq
+ */
+
+// Entities
+export type {
+  GroqMessageRole,
+  GroqMessage,
+  GroqChatRequest,
+  GroqChoice,
+  GroqFinishReason,
+  GroqUsage,
+  GroqChatResponse,
+  GroqChunkChoice,
+  GroqChatChunk,
+  GroqErrorResponse,
+} from "./entities";
+
+export type {
+  GroqConfig,
+  GroqGenerationConfig,
+} from "./entities";
+
+// Interfaces
+export type {
+  TextGenerationOptions,
+  StreamingCallbacks,
+  StructuredGenerationOptions,
+} from "./interfaces";
+
+export type { IGroqChatService, IGroqHttpClient } from "./interfaces";
+
+// Services
+export { textGenerationService, groqHttpClient } from "./services";
+
+// Hooks
+export { useGroq } from "./hooks";
+export type { UseGroqOptions, UseGroqReturn } from "./hooks";
+
+// Constants
+export {
+  GROQ_MODELS,
+  DEFAULT_MODELS,
+  DEFAULT_GENERATION_CONFIG,
+  API_ENDPOINTS,
+  DEFAULT_BASE_URL,
+  TIMEOUTS,
+} from "./constants";
+
+export {
+  GroqErrorType,
+  mapHttpStatusToErrorType,
+  isRetryableError,
+  isAuthError,
+} from "./constants";
+
+// Utils
+export {
+  createUserMessage,
+  createAssistantMessage,
+  createSystemMessage,
+  createTextMessage,
+  promptToMessages,
+  extractTextFromMessages,
+  formatMessagesForDisplay,
+} from "./utils";
+
+export { getUserFriendlyError, formatErrorForLogging } from "./utils";
+
+export { GroqError } from "./utils";

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

@@ -0,0 +1,80 @@
+/**
+ * Chat Service Interfaces
+ * @description Contracts for chat functionality
+ */
+
+import type {
+  ChatMessage,
+  ChatConversation,
+  SendMessageInput,
+  SendMessageResult,
+  ChatConfig,
+  ChatStorage,
+} from "../entities";
+import type { GroqMessage } from "./groq.interface";
+
+/**
+ * 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 */
+  generateAIResponse(conversationId: string, userMessage: string): Promise<ChatMessage>;
+}
+
+/**
+ * Chat hook options
+ */
+export interface UseChatOptions {
+  /** Conversation identifier */
+  readonly conversationId: string;
+  /** Storage implementation */
+  readonly storage?: ChatStorage;
+  /** 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 MessageFormatter {
+  /** 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/index.ts

@@ -1,78 +1,16 @@
 /**
  * @umituz/web-ai-groq-provider
- * Groq AI text generation provider for React web applications
+ * Groq AI text generation and chat provider for React web applications
  *
  * @author umituz
  * @license MIT
  *
  * IMPORTANT: Apps should NOT use this root barrel import.
  * Use subpath imports instead:
- * - @umituz/web-ai-groq-provider/domain
- * - @umituz/web-ai-groq-provider/services
- * - @umituz/web-ai-groq-provider/hooks
+ * - @umituz/web-ai-groq-provider/groq - Groq API client
+ * - @umituz/web-ai-groq-provider/chat - Chat functionality
  */
 
-// Domain layer
-export type {
-  GroqMessageRole,
-  GroqMessage,
-  GroqChatRequest,
-  GroqChoice,
-  GroqFinishReason,
-  GroqUsage,
-  GroqChatResponse,
-  GroqChunkChoice,
-  GroqChatChunk,
-  GroqErrorResponse,
-} from "./domain/entities";
-
-export type {
-  GroqConfig,
-  GroqGenerationConfig,
-  TextGenerationOptions,
-  StreamingCallbacks,
-  StructuredGenerationOptions,
-} from "./domain/interfaces";
-
-export type { IGroqChatService, IGroqHttpClient } from "./domain/interfaces";
-
-// Infrastructure layer
-export {
-  GROQ_MODELS,
-  DEFAULT_MODELS,
-  DEFAULT_GENERATION_CONFIG,
-  API_ENDPOINTS,
-  DEFAULT_BASE_URL,
-  TIMEOUTS,
-} from "./infrastructure/constants";
-
-export {
-  GroqErrorType,
-  mapHttpStatusToErrorType,
-  isRetryableError,
-  isAuthError,
-} from "./infrastructure/constants";
-
-export { groqHttpClient } from "./infrastructure/services";
-export { textGenerationService } from "./infrastructure/services";
-
-export {
-  createUserMessage,
-  createAssistantMessage,
-  createSystemMessage,
-  createTextMessage,
-  promptToMessages,
-  extractTextFromMessages,
-  formatMessagesForDisplay,
-} from "./infrastructure/utils";
-
-export {
-  getUserFriendlyError,
-  formatErrorForLogging,
-} from "./infrastructure/utils";
-
-export { GroqError } from "./infrastructure/utils";
-
-// Presentation layer
-export { useGroq } from "./presentation/hooks";
-export type { UseGroqOptions, UseGroqReturn } from "./presentation/hooks";
+// Re-export domains for backward compatibility
+export * from "./domains/groq";
+export * from "./domains/chat";

package/src/domain/index.ts

@@ -1,32 +0,0 @@
-/**
- * Domain Layer Index
- * Subpath: @umituz/web-ai-groq-provider/domain
- *
- * Exports all entities and interfaces
- */
-
-// Entities
-export type {
-  GroqMessageRole,
-  GroqMessage,
-  GroqChatRequest,
-  GroqChoice,
-  GroqFinishReason,
-  GroqUsage,
-  GroqChatResponse,
-  GroqChunkChoice,
-  GroqChatChunk,
-  GroqErrorResponse,
-  GroqMessageCreateInput,
-} from "./entities";
-
-// Interfaces
-export type {
-  GroqConfig,
-  GroqGenerationConfig,
-  TextGenerationOptions,
-  StreamingCallbacks,
-  StructuredGenerationOptions,
-  IGroqChatService,
-  IGroqHttpClient,
-} from "./interfaces";