@alliance-droid/chat-widget 0.1.0

package/dist/server/ai/openai.js

@@ -0,0 +1,112 @@
+/**
+ * OpenAI Provider
+ *
+ * Fallback AI provider using OpenAI's API
+ */
+const OPENAI_API_URL = 'https://api.openai.com/v1/chat/completions';
+export class OpenAIProvider {
+    apiKey;
+    model;
+    maxTokens;
+    constructor(options) {
+        this.apiKey = options.apiKey;
+        this.model = options.model || 'gpt-4o-mini';
+        this.maxTokens = options.maxTokens || 1024;
+    }
+    async *generateResponse(messages, systemPrompt) {
+        const apiMessages = this.formatMessages(messages, systemPrompt);
+        const response = await fetch(OPENAI_API_URL, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.apiKey}`
+            },
+            body: JSON.stringify({
+                model: this.model,
+                messages: apiMessages,
+                max_tokens: this.maxTokens,
+                stream: true
+            })
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`OpenAI API error: ${response.status} - ${error}`);
+        }
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new Error('No response body');
+        const decoder = new TextDecoder();
+        let buffer = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (line.startsWith('data: ')) {
+                    const data = line.slice(6);
+                    if (data === '[DONE]')
+                        return;
+                    try {
+                        const parsed = JSON.parse(data);
+                        const content = parsed.choices?.[0]?.delta?.content;
+                        if (content) {
+                            yield content;
+                        }
+                    }
+                    catch {
+                        // Skip invalid JSON
+                    }
+                }
+            }
+        }
+    }
+    async summarize(messages) {
+        const conversationText = messages
+            .map(m => `${m.sender}: ${m.content}`)
+            .join('\n');
+        const response = await fetch(OPENAI_API_URL, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.apiKey}`
+            },
+            body: JSON.stringify({
+                model: this.model,
+                messages: [
+                    {
+                        role: 'system',
+                        content: 'Summarize this customer support conversation in 1-2 sentences. Focus on what the customer needs help with.'
+                    },
+                    {
+                        role: 'user',
+                        content: conversationText
+                    }
+                ],
+                max_tokens: 150
+            })
+        });
+        if (!response.ok) {
+            return 'Customer requested support assistance.';
+        }
+        const data = await response.json();
+        return data.choices?.[0]?.message?.content || 'Customer requested support assistance.';
+    }
+    formatMessages(messages, systemPrompt) {
+        const apiMessages = [];
+        if (systemPrompt) {
+            apiMessages.push({ role: 'system', content: systemPrompt });
+        }
+        for (const msg of messages) {
+            if (msg.sender === 'user') {
+                apiMessages.push({ role: 'user', content: msg.content });
+            }
+            else if (msg.sender === 'ai') {
+                apiMessages.push({ role: 'assistant', content: msg.content });
+            }
+        }
+        return apiMessages;
+    }
+}

package/dist/server/ai/provider.d.ts

@@ -0,0 +1,21 @@
+/**
+ * AI Provider Interface
+ *
+ * Abstract interface for AI chat providers
+ */
+import type { Message } from '../../types.js';
+export interface AIProvider {
+    /**
+     * Generate a response to the conversation
+     */
+    generateResponse(messages: Message[], systemPrompt?: string): AsyncGenerator<string, void, unknown>;
+    /**
+     * Generate a summary of the conversation (for escalation)
+     */
+    summarize(messages: Message[]): Promise<string>;
+}
+export interface AIProviderOptions {
+    apiKey: string;
+    model?: string;
+    maxTokens?: number;
+}

package/dist/server/ai/provider.js

@@ -0,0 +1,6 @@
+/**
+ * AI Provider Interface
+ *
+ * Abstract interface for AI chat providers
+ */
+export {};

package/dist/server/ai/xai.d.ts

@@ -0,0 +1,16 @@
+/**
+ * xAI Grok Provider
+ *
+ * Primary AI provider using xAI's Grok model
+ */
+import type { AIProvider, AIProviderOptions } from './provider.js';
+import type { Message } from '../../types.js';
+export declare class XAIProvider implements AIProvider {
+    private apiKey;
+    private model;
+    private maxTokens;
+    constructor(options: AIProviderOptions);
+    generateResponse(messages: Message[], systemPrompt?: string): AsyncGenerator<string, void, unknown>;
+    summarize(messages: Message[]): Promise<string>;
+    private formatMessages;
+}

package/dist/server/ai/xai.js

@@ -0,0 +1,113 @@
+/**
+ * xAI Grok Provider
+ *
+ * Primary AI provider using xAI's Grok model
+ */
+const XAI_API_URL = 'https://api.x.ai/v1/chat/completions';
+export class XAIProvider {
+    apiKey;
+    model;
+    maxTokens;
+    constructor(options) {
+        this.apiKey = options.apiKey;
+        this.model = options.model || 'grok-2-latest';
+        this.maxTokens = options.maxTokens || 1024;
+    }
+    async *generateResponse(messages, systemPrompt) {
+        const apiMessages = this.formatMessages(messages, systemPrompt);
+        const response = await fetch(XAI_API_URL, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.apiKey}`
+            },
+            body: JSON.stringify({
+                model: this.model,
+                messages: apiMessages,
+                max_tokens: this.maxTokens,
+                stream: true
+            })
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`xAI API error: ${response.status} - ${error}`);
+        }
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new Error('No response body');
+        const decoder = new TextDecoder();
+        let buffer = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (line.startsWith('data: ')) {
+                    const data = line.slice(6);
+                    if (data === '[DONE]')
+                        return;
+                    try {
+                        const parsed = JSON.parse(data);
+                        const content = parsed.choices?.[0]?.delta?.content;
+                        if (content) {
+                            yield content;
+                        }
+                    }
+                    catch {
+                        // Skip invalid JSON
+                    }
+                }
+            }
+        }
+    }
+    async summarize(messages) {
+        const conversationText = messages
+            .map(m => `${m.sender}: ${m.content}`)
+            .join('\n');
+        const response = await fetch(XAI_API_URL, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.apiKey}`
+            },
+            body: JSON.stringify({
+                model: this.model,
+                messages: [
+                    {
+                        role: 'system',
+                        content: 'Summarize this customer support conversation in 1-2 sentences. Focus on what the customer needs help with.'
+                    },
+                    {
+                        role: 'user',
+                        content: conversationText
+                    }
+                ],
+                max_tokens: 150
+            })
+        });
+        if (!response.ok) {
+            return 'Customer requested support assistance.';
+        }
+        const data = await response.json();
+        return data.choices?.[0]?.message?.content || 'Customer requested support assistance.';
+    }
+    formatMessages(messages, systemPrompt) {
+        const apiMessages = [];
+        if (systemPrompt) {
+            apiMessages.push({ role: 'system', content: systemPrompt });
+        }
+        for (const msg of messages) {
+            if (msg.sender === 'user') {
+                apiMessages.push({ role: 'user', content: msg.content });
+            }
+            else if (msg.sender === 'ai') {
+                apiMessages.push({ role: 'assistant', content: msg.content });
+            }
+            // Skip system and human messages for AI context
+        }
+        return apiMessages;
+    }
+}

package/dist/server/escalation.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Escalation Manager
+ *
+ * Handles escalation to human support via Telegram
+ */
+import type { ChatSession, EscalationConfig } from '../types.js';
+export declare class EscalationManager {
+    private config;
+    constructor(config: EscalationConfig);
+    /**
+     * Send escalation notification to Telegram
+     */
+    notifySupport(session: ChatSession, summary: string): Promise<boolean>;
+    /**
+     * Escape Markdown special characters for Telegram
+     */
+    private escapeMarkdown;
+}

package/dist/server/escalation.js

@@ -0,0 +1,61 @@
+/**
+ * Escalation Manager
+ *
+ * Handles escalation to human support via Telegram
+ */
+const TELEGRAM_API_URL = 'https://api.telegram.org/bot';
+export class EscalationManager {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Send escalation notification to Telegram
+     */
+    async notifySupport(session, summary) {
+        const joinUrl = this.config.joinUrl(session.id);
+        const recentMessages = session.messages
+            .slice(-5)
+            .map(m => {
+            const icon = m.sender === 'user' ? '👤' : m.sender === 'ai' ? '🤖' : '📢';
+            return `${icon} ${m.content.slice(0, 100)}${m.content.length > 100 ? '...' : ''}`;
+        })
+            .join('\n');
+        const message = `🆘 *Support Request*
+
+*Summary:* ${this.escapeMarkdown(summary)}
+
+*Recent messages:*
+${this.escapeMarkdown(recentMessages)}
+
+➡️ [Join Chat](${joinUrl})`;
+        try {
+            const response = await fetch(`${TELEGRAM_API_URL}${this.config.telegram.botToken}/sendMessage`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    chat_id: this.config.telegram.chatId,
+                    text: message,
+                    parse_mode: 'Markdown',
+                    disable_web_page_preview: true
+                })
+            });
+            if (!response.ok) {
+                const error = await response.text();
+                console.error('[Escalation] Telegram API error:', error);
+                return false;
+            }
+            return true;
+        }
+        catch (err) {
+            console.error('[Escalation] Failed to send Telegram notification:', err);
+            return false;
+        }
+    }
+    /**
+     * Escape Markdown special characters for Telegram
+     */
+    escapeMarkdown(text) {
+        return text.replace(/[_*[\]()~`>#+\-=|{}.!]/g, '\\$&');
+    }
+}

package/dist/server/handler.d.ts

@@ -0,0 +1,8 @@
+/**
+ * WebSocket Chat Handler
+ *
+ * Main server-side handler for chat connections
+ */
+import type { WebSocket } from 'ws';
+import type { ChatServerConfig } from '../types.js';
+export declare function createChatHandler(config: ChatServerConfig): (ws: WebSocket) => void;

package/dist/server/handler.js

@@ -0,0 +1,235 @@
+/**
+ * WebSocket Chat Handler
+ *
+ * Main server-side handler for chat connections
+ */
+import { XAIProvider } from './ai/xai.js';
+import { OpenAIProvider } from './ai/openai.js';
+import { AnthropicProvider } from './ai/anthropic.js';
+import { SessionManager } from './session.js';
+import { EscalationManager } from './escalation.js';
+export function createChatHandler(config) {
+    const aiProvider = createAIProvider(config.ai);
+    const sessionManager = new SessionManager(config.sessionTTL);
+    const escalationManager = config.escalation
+        ? new EscalationManager(config.escalation)
+        : null;
+    // Track active connections by session
+    const connections = new Map();
+    return function handleConnection(ws) {
+        let clientConnection = null;
+        ws.on('message', async (data) => {
+            try {
+                const message = JSON.parse(data.toString());
+                await handleMessage(message);
+            }
+            catch (err) {
+                console.error('[ChatHandler] Error handling message:', err);
+                sendError('Failed to process message');
+            }
+        });
+        ws.on('close', () => {
+            if (clientConnection) {
+                removeConnection(clientConnection);
+            }
+        });
+        async function handleMessage(message) {
+            switch (message.type) {
+                case 'message':
+                    await handleChatMessage(message);
+                    break;
+                case 'escalate':
+                    await handleEscalation();
+                    break;
+                case 'join':
+                    await handleSupportJoin(message);
+                    break;
+                case 'typing':
+                    broadcastToSession(clientConnection?.sessionId, {
+                        type: 'typing',
+                        sender: clientConnection?.isSupport ? 'human' : 'user'
+                    });
+                    break;
+            }
+        }
+        async function handleChatMessage(message) {
+            if (!clientConnection) {
+                // New connection - create session
+                const session = sessionManager.create();
+                clientConnection = { ws, sessionId: session.id, isSupport: false };
+                addConnection(clientConnection);
+                // Send connected message with session ID
+                send({ type: 'connected', sessionId: session.id });
+            }
+            const session = sessionManager.get(clientConnection.sessionId);
+            if (!session) {
+                sendError('Session not found');
+                return;
+            }
+            // Store user message
+            const userMessage = {
+                id: generateId(),
+                content: message.content || '',
+                sender: clientConnection.isSupport ? 'human' : 'user',
+                timestamp: Date.now()
+            };
+            sessionManager.addMessage(session.id, userMessage);
+            // Broadcast user message to all participants
+            broadcastToSession(session.id, {
+                type: 'message',
+                ...userMessage
+            });
+            // If not escalated, generate AI response
+            if (session.status === 'ai' && !clientConnection.isSupport) {
+                await generateAIResponse(session);
+            }
+        }
+        async function generateAIResponse(session) {
+            const messageId = generateId();
+            // Send typing indicator
+            broadcastToSession(session.id, { type: 'typing', sender: 'ai' });
+            try {
+                let fullContent = '';
+                for await (const chunk of aiProvider.generateResponse(session.messages, config.ai.systemPrompt)) {
+                    fullContent += chunk;
+                    // Stream partial response
+                    broadcastToSession(session.id, {
+                        type: 'message',
+                        id: messageId,
+                        content: fullContent,
+                        sender: 'ai',
+                        timestamp: Date.now(),
+                        streaming: true
+                    });
+                }
+                // Store final message
+                const aiMessage = {
+                    id: messageId,
+                    content: fullContent,
+                    sender: 'ai',
+                    timestamp: Date.now()
+                };
+                sessionManager.addMessage(session.id, aiMessage);
+                // Send final message (streaming = false)
+                broadcastToSession(session.id, {
+                    type: 'message',
+                    ...aiMessage,
+                    streaming: false
+                });
+            }
+            catch (err) {
+                console.error('[ChatHandler] AI generation error:', err);
+                sendError('Failed to generate response');
+            }
+        }
+        async function handleEscalation() {
+            if (!clientConnection)
+                return;
+            const session = sessionManager.get(clientConnection.sessionId);
+            if (!session) {
+                sendError('Session not found');
+                return;
+            }
+            sessionManager.setStatus(session.id, 'escalating');
+            // Notify via Telegram
+            if (escalationManager) {
+                const summary = await aiProvider.summarize(session.messages);
+                const sent = await escalationManager.notifySupport(session, summary);
+                if (sent) {
+                    broadcastToSession(session.id, {
+                        type: 'status',
+                        content: 'Support has been notified. Please wait...'
+                    });
+                }
+                else {
+                    sendError('Failed to notify support');
+                    sessionManager.setStatus(session.id, 'ai');
+                }
+            }
+            else {
+                sendError('Escalation not configured');
+                sessionManager.setStatus(session.id, 'ai');
+            }
+        }
+        async function handleSupportJoin(message) {
+            const sessionId = message.sessionId;
+            if (!sessionId) {
+                sendError('Session ID required');
+                return;
+            }
+            const session = sessionManager.get(sessionId);
+            if (!session) {
+                sendError('Session not found');
+                return;
+            }
+            // Try to claim the session
+            const agentId = generateId();
+            const claimed = sessionManager.assignSupport(sessionId, agentId);
+            if (!claimed && session.supportAgentId) {
+                sendError('Session already claimed by another agent');
+                return;
+            }
+            // Register support connection
+            clientConnection = { ws, sessionId, isSupport: true };
+            addConnection(clientConnection);
+            // Send session history to support
+            send({ type: 'connected', sessionId });
+            for (const msg of session.messages) {
+                send({ type: 'message', ...msg });
+            }
+            // Notify user that support joined
+            broadcastToSession(sessionId, { type: 'escalated' });
+        }
+        function send(message) {
+            if (ws.readyState === ws.OPEN) {
+                ws.send(JSON.stringify(message));
+            }
+        }
+        function sendError(error) {
+            send({ type: 'error', error });
+        }
+        function addConnection(conn) {
+            const existing = connections.get(conn.sessionId) || [];
+            existing.push(conn);
+            connections.set(conn.sessionId, existing);
+        }
+        function removeConnection(conn) {
+            const existing = connections.get(conn.sessionId) || [];
+            const filtered = existing.filter(c => c.ws !== conn.ws);
+            if (filtered.length > 0) {
+                connections.set(conn.sessionId, filtered);
+            }
+            else {
+                connections.delete(conn.sessionId);
+            }
+        }
+        function broadcastToSession(sessionId, message) {
+            if (!sessionId)
+                return;
+            const sessionConnections = connections.get(sessionId) || [];
+            for (const conn of sessionConnections) {
+                if (conn.ws.readyState === conn.ws.OPEN) {
+                    conn.ws.send(JSON.stringify(message));
+                }
+            }
+        }
+    };
+}
+function createAIProvider(config) {
+    const options = {
+        apiKey: config.apiKey,
+        model: config.model
+    };
+    switch (config.provider) {
+        case 'openai':
+            return new OpenAIProvider(options);
+        case 'anthropic':
+            return new AnthropicProvider(options);
+        case 'xai':
+        default:
+            return new XAIProvider(options);
+    }
+}
+function generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}

package/dist/server/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Server-side exports
+ */
+export { createChatHandler } from './handler.js';
+export { SessionManager } from './session.js';
+export { EscalationManager } from './escalation.js';
+export { XAIProvider } from './ai/xai.js';
+export { OpenAIProvider } from './ai/openai.js';
+export { AnthropicProvider } from './ai/anthropic.js';
+export type { AIProvider, AIProviderOptions } from './ai/provider.js';
+export type { ChatServerConfig, AIProviderConfig, EscalationConfig, ChatSession } from '../types.js';

package/dist/server/index.js

@@ -0,0 +1,10 @@
+/**
+ * Server-side exports
+ */
+export { createChatHandler } from './handler.js';
+export { SessionManager } from './session.js';
+export { EscalationManager } from './escalation.js';
+// AI Providers
+export { XAIProvider } from './ai/xai.js';
+export { OpenAIProvider } from './ai/openai.js';
+export { AnthropicProvider } from './ai/anthropic.js';

package/dist/server/session.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Session Manager
+ *
+ * In-memory session storage (Redis adapter TODO)
+ */
+import type { ChatSession, Message, ChatStatus } from '../types.js';
+export declare class SessionManager {
+    private sessions;
+    private ttl;
+    private cleanupInterval;
+    constructor(ttlMs?: number);
+    /**
+     * Create a new session
+     */
+    create(userId?: string, userMeta?: Record<string, unknown>): ChatSession;
+    /**
+     * Get a session by ID
+     */
+    get(id: string): ChatSession | undefined;
+    /**
+     * Add a message to a session
+     */
+    addMessage(sessionId: string, message: Message): void;
+    /**
+     * Update session status
+     */
+    setStatus(sessionId: string, status: ChatStatus): void;
+    /**
+     * Assign a support agent to a session
+     */
+    assignSupport(sessionId: string, agentId: string): boolean;
+    /**
+     * Delete a session
+     */
+    delete(id: string): void;
+    /**
+     * Cleanup expired sessions
+     */
+    private cleanup;
+    /**
+     * Check if session is expired
+     */
+    private isExpired;
+    /**
+     * Generate unique session ID
+     */
+    private generateId;
+    /**
+     * Cleanup on shutdown
+     */
+    destroy(): void;
+}