agenticaichat 1.0.1 → 1.0.4

package/dist/llm/providers/GeminiProvider.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiProvider = void 0;
+const generative_ai_1 = require("@google/generative-ai");
+const logger_1 = require("../../utils/logger");
+class GeminiProvider {
+    constructor(config) {
+        this.configured = false;
+        if (!config.apiKey) {
+            logger_1.logger.error('Gemini API key is required');
+            return;
+        }
+        this.client = new generative_ai_1.GoogleGenerativeAI(config.apiKey);
+        this.model = config.model || 'gemini-1.5-pro';
+        this.configured = true;
+        logger_1.logger.info(`Gemini Provider initialized with model: ${this.model}`);
+    }
+    isConfigured() {
+        return this.configured;
+    }
+    async generateSQL(userQuery, schema) {
+        if (!this.configured) {
+            throw new Error('Gemini Provider not configured');
+        }
+        try {
+            logger_1.logger.info('Generating SQL with Gemini...');
+            const model = this.client.getGenerativeModel({ model: this.model });
+            const schemaDescription = this.formatSchema(schema);
+            const prompt = this.buildSQLPrompt(userQuery, schemaDescription);
+            const result = await model.generateContent(prompt);
+            const response = await result.response;
+            const sqlQuery = response.text().trim();
+            // Remove markdown code blocks
+            const cleanedSQL = sqlQuery
+                .replace(/```sql\n?/g, '')
+                .replace(/```\n?/g, '')
+                .trim();
+            logger_1.logger.debug_log('Generated SQL:', cleanedSQL);
+            return cleanedSQL;
+        }
+        catch (error) {
+            logger_1.logger.error('Gemini SQL generation failed', error);
+            throw error;
+        }
+    }
+    async generateHumanResponse(userQuery, queryResult) {
+        if (!this.configured) {
+            throw new Error('Gemini Provider not configured');
+        }
+        try {
+            logger_1.logger.info('Generating human response with Gemini...');
+            const model = this.client.getGenerativeModel({ model: this.model });
+            const prompt = `
+User asked: "${userQuery}"
+
+Database returned this result:
+${JSON.stringify(queryResult, null, 2)}
+
+Please provide a clear, conversational answer in Hindi/English mix (Hinglish) that explains this data to a business owner. Be specific with numbers.
+`;
+            const result = await model.generateContent(prompt);
+            const response = await result.response;
+            const answer = response.text().trim() || 'Sorry, I could not generate a response.';
+            logger_1.logger.debug_log('Generated response:', answer);
+            return answer;
+        }
+        catch (error) {
+            logger_1.logger.error('Gemini response generation failed', error);
+            throw error;
+        }
+    }
+    buildSQLPrompt(userQuery, schemaDescription) {
+        return `
+You are a SQL expert. Generate a SQL query based on the user's question.
+
+Database Schema:
+${schemaDescription}
+
+User Question: "${userQuery}"
+
+Rules:
+1. Return ONLY the SQL query, nothing else
+2. Use correct table and column names from the schema
+3. Add WHERE clauses for date filtering when needed
+4. Use SUM, COUNT, AVG for aggregations
+5. Handle both singular and plural forms
+6. Use CURRENT_DATE for time-based queries
+7. Make sure the query is syntactically correct
+
+SQL Query:
+`;
+    }
+    formatSchema(schema) {
+        let description = '';
+        for (const table of schema.tables) {
+            description += `\nTable: ${table.name}\n`;
+            description += 'Columns:\n';
+            for (const column of table.columns) {
+                description += `  - ${column.name} (${column.type})${column.nullable ? ' [nullable]' : ''}\n`;
+            }
+        }
+        return description;
+    }
+}
+exports.GeminiProvider = GeminiProvider;

package/dist/llm/providers/GrokProvider.d.ts

@@ -0,0 +1,14 @@
+import { ILLMProvider, GrokProviderConfig } from '../types';
+import { DatabaseSchema } from '../../types';
+export declare class GrokProvider implements ILLMProvider {
+    private apiKey;
+    private model;
+    private configured;
+    private baseURL;
+    constructor(config: GrokProviderConfig);
+    isConfigured(): boolean;
+    generateSQL(userQuery: string, schema: DatabaseSchema): Promise<string>;
+    generateHumanResponse(userQuery: string, queryResult: any): Promise<string>;
+    private buildSQLPrompt;
+    private formatSchema;
+}

package/dist/llm/providers/GrokProvider.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrokProvider = void 0;
+const axios_1 = __importDefault(require("axios"));
+const logger_1 = require("../../utils/logger");
+class GrokProvider {
+    constructor(config) {
+        this.configured = false;
+        this.baseURL = 'https://api.x.ai/v1';
+        if (!config.apiKey) {
+            logger_1.logger.error('Grok API key is required');
+            return;
+        }
+        this.apiKey = config.apiKey;
+        this.model = config.model || 'grok-beta';
+        this.configured = true;
+        logger_1.logger.info(`Grok Provider initialized with model: ${this.model}`);
+    }
+    isConfigured() {
+        return this.configured;
+    }
+    async generateSQL(userQuery, schema) {
+        if (!this.configured) {
+            throw new Error('Grok Provider not configured');
+        }
+        try {
+            logger_1.logger.info('Generating SQL with Grok...');
+            const schemaDescription = this.formatSchema(schema);
+            const prompt = this.buildSQLPrompt(userQuery, schemaDescription);
+            const response = await axios_1.default.post(`${this.baseURL}/chat/completions`, {
+                model: this.model,
+                messages: [
+                    {
+                        role: 'system',
+                        content: 'You are an expert SQL query generator. Generate ONLY valid SQL queries without any explanation or markdown.'
+                    },
+                    {
+                        role: 'user',
+                        content: prompt
+                    }
+                ],
+                temperature: 0.2,
+                max_tokens: 500
+            }, {
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            const sqlQuery = response.data.choices[0]?.message?.content?.trim() || '';
+            // Remove markdown code blocks
+            const cleanedSQL = sqlQuery
+                .replace(/```sql\n?/g, '')
+                .replace(/```\n?/g, '')
+                .trim();
+            logger_1.logger.debug_log('Generated SQL:', cleanedSQL);
+            return cleanedSQL;
+        }
+        catch (error) {
+            logger_1.logger.error('Grok SQL generation failed', error);
+            throw error;
+        }
+    }
+    async generateHumanResponse(userQuery, queryResult) {
+        if (!this.configured) {
+            throw new Error('Grok Provider not configured');
+        }
+        try {
+            logger_1.logger.info('Generating human response with Grok...');
+            const prompt = `
+User asked: "${userQuery}"
+
+Database returned this result:
+${JSON.stringify(queryResult, null, 2)}
+
+Please provide a clear, conversational answer in Hindi/English mix (Hinglish) that explains this data to a business owner. Be specific with numbers.
+`;
+            const response = await axios_1.default.post(`${this.baseURL}/chat/completions`, {
+                model: this.model,
+                messages: [
+                    {
+                        role: 'system',
+                        content: 'You are a helpful business analytics assistant. Explain data clearly in Hinglish (Hindi-English mix).'
+                    },
+                    {
+                        role: 'user',
+                        content: prompt
+                    }
+                ],
+                temperature: 0.7,
+                max_tokens: 300
+            }, {
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json'
+                }
+            });
+            const answer = response.data.choices[0]?.message?.content?.trim() ||
+                'Sorry, I could not generate a response.';
+            logger_1.logger.debug_log('Generated response:', answer);
+            return answer;
+        }
+        catch (error) {
+            logger_1.logger.error('Grok response generation failed', error);
+            throw error;
+        }
+    }
+    buildSQLPrompt(userQuery, schemaDescription) {
+        return `
+You are a SQL expert. Generate a SQL query based on the user's question.
+
+Database Schema:
+${schemaDescription}
+
+User Question: "${userQuery}"
+
+Rules:
+1. Return ONLY the SQL query, nothing else
+2. Use correct table and column names from the schema
+3. Add WHERE clauses for date filtering when needed
+4. Use SUM, COUNT, AVG for aggregations
+5. Handle both singular and plural forms
+6. Use CURRENT_DATE for time-based queries
+7. Make sure the query is syntactically correct
+
+SQL Query:
+`;
+    }
+    formatSchema(schema) {
+        let description = '';
+        for (const table of schema.tables) {
+            description += `\nTable: ${table.name}\n`;
+            description += 'Columns:\n';
+            for (const column of table.columns) {
+                description += `  - ${column.name} (${column.type})${column.nullable ? ' [nullable]' : ''}\n`;
+            }
+        }
+        return description;
+    }
+}
+exports.GrokProvider = GrokProvider;

package/dist/llm/providers/GroqProvider.js

@@ -0,0 +1,148 @@
+"use strict";
+// import axios from 'axios';
+// import { ILLMProvider, GroqProviderConfig } from '../types';
+// import { DatabaseSchema } from '../../types';
+// import { logger } from '../../utils/logger';
+// export class GroqProvider implements ILLMProvider {
+//   private apiKey: string;
+//   private model: string;
+//   private configured: boolean = false;
+//   private baseURL: string = 'https://api.groq.com/openai/v1';
+//   constructor(config: GroqProviderConfig) {
+//     if (!config.apiKey) {
+//       logger.error('Groq API key is required');
+//       return;
+//     }
+//     this.apiKey = config.apiKey;
+//     this.model = config.model || 'llama3-70b-8192';
+//     this.configured = true;
+//     logger.info(`Groq Provider initialized with model: ${this.model}`);
+//   }
+//   isConfigured(): boolean {
+//     return this.configured;
+//   }
+//   async generateSQL(
+//     userQuery: string,
+//     schema: DatabaseSchema
+//   ): Promise<string> {
+//     if (!this.configured) {
+//       throw new Error('Groq Provider not configured');
+//     }
+//     try {
+//       logger.info('Generating SQL with Groq...');
+//       const schemaDescription = this.formatSchema(schema);
+//       const prompt = this.buildSQLPrompt(userQuery, schemaDescription);
+//       const response = await axios.post(
+//         `${this.baseURL}/chat/completions`,
+//         {
+//           model: this.model,
+//           messages: [
+//             {
+//               role: 'system',
+//               content: 'You are an expert SQL query generator. Generate ONLY valid SQL queries without any explanation or markdown.'
+//             },
+//             {
+//               role: 'user',
+//               content: prompt
+//             }
+//           ],
+//           temperature: 0.2,
+//           max_tokens: 500
+//         },
+//         {
+//           headers: {
+//             'Authorization': `Bearer ${this.apiKey}`,
+//             'Content-Type': 'application/json'
+//           }
+//         }
+//       );
+//       const sqlQuery = response.data.choices[0]?.message?.content?.trim() || '';
+//       // Remove markdown code blocks
+//       const cleanedSQL = sqlQuery
+//         .replace(/```sql\n?/g, '')
+//         .replace(/```\n?/g, '')
+//         .trim();
+//       logger.debug_log('Generated SQL:', cleanedSQL);
+//       return cleanedSQL;
+//     } catch (error) {
+//       logger.error('Groq SQL generation failed', error as Error);
+//       throw error;
+//     }
+//   }
+//   async generateHumanResponse(
+//     userQuery: string,
+//     queryResult: any
+//   ): Promise<string> {
+//     if (!this.configured) {
+//       throw new Error('Groq Provider not configured');
+//     }
+//     try {
+//       logger.info('Generating human response with Groq...');
+//       const prompt = `
+// User asked: "${userQuery}"
+// Database returned this result:
+// ${JSON.stringify(queryResult, null, 2)}
+// Please provide a clear, conversational answer in Hindi/English mix (Hinglish) that explains this data to a business owner. Be specific with numbers.
+// `;
+//       const response = await axios.post(
+//         `${this.baseURL}/chat/completions`,
+//         {
+//           model: this.model,
+//           messages: [
+//             {
+//               role: 'system',
+//               content: 'You are a helpful business analytics assistant. Explain data clearly in Hinglish (Hindi-English mix).'
+//             },
+//             {
+//               role: 'user',
+//               content: prompt
+//             }
+//           ],
+//           temperature: 0.7,
+//           max_tokens: 300
+//         },
+//         {
+//           headers: {
+//             'Authorization': `Bearer ${this.apiKey}`,
+//             'Content-Type': 'application/json'
+//           }
+//         }
+//       );
+//       const answer = response.data.choices[0]?.message?.content?.trim() || 
+//         'Sorry, I could not generate a response.';
+//       logger.debug_log('Generated response:', answer);
+//       return answer;
+//     } catch (error) {
+//       logger.error('Groq response generation failed', error as Error);
+//       throw error;
+//     }
+//   }
+//   private buildSQLPrompt(userQuery: string, schemaDescription: string): string {
+//     return `
+// You are a SQL expert. Generate a SQL query based on the user's question.
+// Database Schema:
+// ${schemaDescription}
+// User Question: "${userQuery}"
+// Rules:
+// 1. Return ONLY the SQL query, nothing else
+// 2. Use correct table and column names from the schema
+// 3. Add WHERE clauses for date filtering when needed
+// 4. Use SUM, COUNT, AVG for aggregations
+// 5. Handle both singular and plural forms
+// 6. Use CURRENT_DATE for time-based queries
+// 7. Make sure the query is syntactically correct
+// SQL Query:
+// `;
+//   }
+//   private formatSchema(schema: DatabaseSchema): string {
+//     let description = '';
+//     for (const table of schema.tables) {
+//       description += `\nTable: ${table.name}\n`;
+//       description += 'Columns:\n';
+//       for (const column of table.columns) {
+//         description += `  - ${column.name} (${column.type})${column.nullable ? ' [nullable]' : ''}\n`;
+//       }
+//     }
+//     return description;
+//   }
+// }

package/dist/llm/providers/OpenAIProvider.d.ts

@@ -0,0 +1,13 @@
+import { ILLMProvider, OpenAIProviderConfig } from '../types';
+import { DatabaseSchema } from '../../types';
+export declare class OpenAIProvider implements ILLMProvider {
+    private client;
+    private model;
+    private configured;
+    constructor(config: OpenAIProviderConfig);
+    isConfigured(): boolean;
+    generateSQL(userQuery: string, schema: DatabaseSchema): Promise<string>;
+    generateHumanResponse(userQuery: string, queryResult: any): Promise<string>;
+    private buildSQLPrompt;
+    private formatSchema;
+}

package/dist/llm/providers/OpenAIProvider.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIProvider = void 0;
+const openai_1 = __importDefault(require("openai"));
+const logger_1 = require("../../utils/logger");
+class OpenAIProvider {
+    constructor(config) {
+        this.configured = false;
+        if (!config.apiKey) {
+            logger_1.logger.error('OpenAI API key is required');
+            return;
+        }
+        this.client = new openai_1.default({
+            apiKey: config.apiKey,
+            organization: config.organization
+        });
+        this.model = config.model || 'gpt-3.5-turbo';
+        this.configured = true;
+        logger_1.logger.info(`OpenAI Provider initialized with model: ${this.model}`);
+    }
+    isConfigured() {
+        return this.configured;
+    }
+    async generateSQL(userQuery, schema) {
+        if (!this.configured) {
+            throw new Error('OpenAI Provider not configured');
+        }
+        try {
+            logger_1.logger.info('Generating SQL with OpenAI...');
+            const schemaDescription = this.formatSchema(schema);
+            const prompt = this.buildSQLPrompt(userQuery, schemaDescription);
+            const response = await this.client.chat.completions.create({
+                model: this.model,
+                messages: [
+                    {
+                        role: 'system',
+                        content: 'You are an expert SQL query generator. Generate ONLY valid SQL queries without any explanation or markdown.'
+                    },
+                    {
+                        role: 'user',
+                        content: prompt
+                    }
+                ],
+                temperature: 0.2,
+                max_tokens: 500
+            });
+            const sqlQuery = response.choices[0]?.message?.content?.trim() || '';
+            // Remove markdown code blocks if present
+            const cleanedSQL = sqlQuery
+                .replace(/```sql\n?/g, '')
+                .replace(/```\n?/g, '')
+                .trim();
+            logger_1.logger.debug_log('Generated SQL:', cleanedSQL);
+            return cleanedSQL;
+        }
+        catch (error) {
+            logger_1.logger.error('OpenAI SQL generation failed', error);
+            throw error;
+        }
+    }
+    async generateHumanResponse(userQuery, queryResult) {
+        if (!this.configured) {
+            throw new Error('OpenAI Provider not configured');
+        }
+        try {
+            logger_1.logger.info('Generating human response with OpenAI...');
+            const prompt = `
+User asked: "${userQuery}"
+
+Database returned this result:
+${JSON.stringify(queryResult, null, 2)}
+
+Please provide a clear, conversational answer in Hindi/English mix (Hinglish) that explains this data to a business owner. Be specific with numbers.
+`;
+            const response = await this.client.chat.completions.create({
+                model: this.model,
+                messages: [
+                    {
+                        role: 'system',
+                        content: 'You are a helpful business analytics assistant. Explain data clearly in Hinglish (Hindi-English mix).'
+                    },
+                    {
+                        role: 'user',
+                        content: prompt
+                    }
+                ],
+                temperature: 0.7,
+                max_tokens: 300
+            });
+            const answer = response.choices[0]?.message?.content?.trim() ||
+                'Sorry, I could not generate a response.';
+            logger_1.logger.debug_log('Generated response:', answer);
+            return answer;
+        }
+        catch (error) {
+            logger_1.logger.error('OpenAI response generation failed', error);
+            throw error;
+        }
+    }
+    buildSQLPrompt(userQuery, schemaDescription) {
+        return `
+You are a SQL expert. Generate a SQL query based on the user's question.
+
+Database Schema:
+${schemaDescription}
+
+User Question: "${userQuery}"
+
+Rules:
+1. Return ONLY the SQL query, nothing else
+2. Use correct table and column names from the schema
+3. Add WHERE clauses for date filtering when needed
+4. Use SUM, COUNT, AVG for aggregations
+5. Handle both singular and plural forms (sales/sale, orders/order)
+6. Use CURRENT_DATE, CURRENT_MONTH for time-based queries
+7. Make sure the query is syntactically correct
+
+SQL Query:
+`;
+    }
+    formatSchema(schema) {
+        let description = '';
+        for (const table of schema.tables) {
+            description += `\nTable: ${table.name}\n`;
+            description += 'Columns:\n';
+            for (const column of table.columns) {
+                description += `  - ${column.name} (${column.type})${column.nullable ? ' [nullable]' : ''}\n`;
+            }
+        }
+        return description;
+    }
+}
+exports.OpenAIProvider = OpenAIProvider;

package/dist/llm/providers/TogetherAIProvider.d.ts

@@ -0,0 +1,14 @@
+import { ILLMProvider, TogetherAIProviderConfig } from '../types';
+import { DatabaseSchema } from '../../types';
+export declare class TogetherAIProvider implements ILLMProvider {
+    private apiKey;
+    private model;
+    private configured;
+    private baseURL;
+    constructor(config: TogetherAIProviderConfig);
+    isConfigured(): boolean;
+    generateSQL(userQuery: string, schema: DatabaseSchema): Promise<string>;
+    generateHumanResponse(userQuery: string, queryResult: any): Promise<string>;
+    private buildSQLPrompt;
+    private formatSchema;
+}