outlet-orm 7.0.0 → 9.0.1

package/src/AI/MCPServer.js

@@ -112,6 +112,33 @@ const TOOL_DEFINITIONS = [
       },
       required: ['filePath', 'consent']
     }
+  },
+  {
+    name: 'ai_query',
+    description: 'Convert a natural language question into SQL and execute it. Requires an AI provider (AiBridge).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        question: { type: 'string', description: 'Natural language question, e.g. "Show me the top 5 users by order count"' },
+        provider: { type: 'string', description: 'AI provider to use (default: openai)' },
+        model: { type: 'string', description: 'AI model to use (default: gpt-4o-mini)' },
+        safe_mode: { type: 'boolean', description: 'Only allow SELECT queries (default: true)' }
+      },
+      required: ['question']
+    }
+  },
+  {
+    name: 'query_optimize',
+    description: 'Analyze a SQL query using AI and return optimization suggestions, rewritten query, and index recommendations.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        sql: { type: 'string', description: 'The SQL query to optimize' },
+        provider: { type: 'string', description: 'AI provider to use (default: openai)' },
+        model: { type: 'string', description: 'AI model to use (default: gpt-4o-mini)' }
+      },
+      required: ['sql']
+    }
   }
 ];
 
@@ -313,6 +340,8 @@ class MCPServer extends EventEmitter {
     case 'model_list':        return this._toolModelList();
     case 'backup_create':     return this._toolBackupCreate(args);
     case 'backup_restore':    return this._toolBackupRestore(args);
+    case 'ai_query':          return this._toolAiQuery(args);
+    case 'query_optimize':    return this._toolQueryOptimize(args);
     default:
       throw new Error(`Unknown tool: ${name}`);
     }
@@ -610,6 +639,90 @@ class MCPServer extends EventEmitter {
     return `Backup restored from: ${args.filePath}`;
   }
 
+  // ── ai_query (NL → SQL) ───────────────────────────────────────
+
+  async _toolAiQuery(args) {
+    if (!args.question) throw new Error('A natural language question is required.');
+    const conn = await this._getConnection();
+    const manager = this._getAiBridgeManager();
+    if (!manager) throw new Error('AiBridge is not configured. Set OPENAI_API_KEY or configure a provider.');
+
+    const AIQueryBuilder = require('./AIQueryBuilder');
+    const builder = new AIQueryBuilder(manager, conn);
+
+    if (args.provider || args.model) {
+      builder.using(args.provider || 'openai', args.model || 'gpt-4o-mini');
+    }
+    if (args.safe_mode === false) {
+      builder.safeMode(false);
+    }
+
+    const result = await builder.query(args.question);
+    return {
+      sql: result.sql,
+      params: result.params,
+      explanation: result.explanation,
+      results: result.results,
+      error: result.error || null
+    };
+  }
+
+  // ── query_optimize ─────────────────────────────────────────────
+
+  async _toolQueryOptimize(args) {
+    if (!args.sql) throw new Error('SQL query is required.');
+    const conn = await this._getConnection();
+    const manager = this._getAiBridgeManager();
+    if (!manager) throw new Error('AiBridge is not configured. Set OPENAI_API_KEY or configure a provider.');
+
+    const AIQueryOptimizer = require('./AIQueryOptimizer');
+    const optimizer = new AIQueryOptimizer(manager, conn);
+
+    if (args.provider || args.model) {
+      optimizer.using(args.provider || 'openai', args.model || 'gpt-4o-mini');
+    }
+
+    const result = await optimizer.optimize(args.sql);
+    return {
+      original: result.original,
+      optimized: result.optimized,
+      suggestions: result.suggestions,
+      explanation: result.explanation,
+      indexes: result.indexes
+    };
+  }
+
+  // ── AiBridge manager helper ────────────────────────────────────
+
+  /**
+   * Lazily creates an AiBridge manager from environment variables.
+   * @returns {import('./Bridge/AiBridgeManager')|null}
+   */
+  _getAiBridgeManager() {
+    if (this._aiBridgeManager) return this._aiBridgeManager;
+
+    try {
+      const AiBridgeManager = require('./AiBridgeManager');
+      const config = {};
+
+      // Auto-detect providers from env
+      if (process.env.OPENAI_API_KEY)   config.openai   = { api_key: process.env.OPENAI_API_KEY };
+      if (process.env.OLLAMA_ENDPOINT)  config.ollama   = { endpoint: process.env.OLLAMA_ENDPOINT };
+      if (process.env.CLAUDE_API_KEY)   config.claude   = { api_key: process.env.CLAUDE_API_KEY };
+      if (process.env.GEMINI_API_KEY)   config.gemini   = { api_key: process.env.GEMINI_API_KEY };
+      if (process.env.GROK_API_KEY)     config.grok     = { api_key: process.env.GROK_API_KEY };
+      if (process.env.MISTRAL_API_KEY)  config.mistral  = { api_key: process.env.MISTRAL_API_KEY };
+      if (process.env.ONN_API_KEY)      config.onn      = { api_key: process.env.ONN_API_KEY };
+
+      if (Object.keys(config).length === 0) return null;
+
+      this._aiBridgeManager = new AiBridgeManager(config);
+      return this._aiBridgeManager;
+    } catch {
+      return null;
+    }
+  }
+
   // ─── Template helpers ──────────────────────────────────────────
 
   _extractTableName(migrationName) {

package/src/AI/Providers/ClaudeProvider.js

@@ -0,0 +1,64 @@
+'use strict';
+
+/**
+ * ClaudeProvider
+ * Anthropic Messages API. System messages are converted to user role.
+ * Streaming is simulated via chunk-splitting (60-char chunks).
+ */
+class ClaudeProvider {
+  /**
+   * @param {string} apiKey
+   * @param {string} [endpoint='https://api.anthropic.com/v1/messages']
+   */
+  constructor(apiKey, endpoint = 'https://api.anthropic.com/v1/messages') {
+    this.apiKey = apiKey;
+    this.endpoint = endpoint;
+  }
+
+  /** @private */
+  _headers() {
+    return {
+      'x-api-key': this.apiKey,
+      'anthropic-version': '2023-06-01',
+      'Content-Type': 'application/json',
+      'Accept': 'application/json',
+    };
+  }
+
+  async chat(messages, options = {}) {
+    // Convert system messages to user role (Claude requirement)
+    const converted = messages.map(m => {
+      if ((m.role || '') === 'system') return { role: 'user', content: m.content };
+      return m;
+    });
+
+    const payload = {
+      model: options.model || 'claude-3-opus-20240229',
+      max_tokens: options.max_tokens || 512,
+      messages: converted,
+    };
+    if (options.temperature !== undefined) payload.temperature = options.temperature;
+
+    const res = await fetch(this.endpoint, {
+      method: 'POST',
+      headers: this._headers(),
+      body: JSON.stringify(payload),
+    });
+    const data = await res.json();
+    return data || {};
+  }
+
+  async *stream(messages, options = {}) {
+    const full = await this.chat(messages, options);
+    let text = '';
+    if (full?.content?.[0]?.text) text = full.content[0].text;
+    // Simulated: yield 60-char chunks
+    for (let i = 0; i < text.length; i += 60) {
+      yield text.slice(i, i + 60);
+    }
+  }
+
+  supportsStreaming() { return true; } // simulated
+}
+
+module.exports = ClaudeProvider;

package/src/AI/Providers/CustomOpenAIProvider.js

@@ -0,0 +1,238 @@
+'use strict';
+
+const JsonSchemaValidator = require('../Support/JsonSchemaValidator');
+
+/**
+ * CustomOpenAIProvider
+ * Fully configurable OpenAI-compatible provider.
+ * Works with Azure OpenAI, proxies, OpenRouter, self-hosted endpoints, etc.
+ * Supports chat, streaming (SSE), embeddings, images, audio TTS/STT, and models.
+ */
+class CustomOpenAIProvider {
+  /**
+   * @param {string} apiKey
+   * @param {string} baseUrl
+   * @param {Object} [paths={}]
+   * @param {string} [authHeader='Authorization']
+   * @param {string} [authPrefix='Bearer ']
+   * @param {Object} [extraHeaders={}]
+   */
+  constructor(apiKey, baseUrl, paths = {}, authHeader = 'Authorization', authPrefix = 'Bearer ', extraHeaders = {}) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl.replace(/\/+$/, '');
+    this.paths = paths;
+    this.authHeader = authHeader;
+    this.authPrefix = authPrefix;
+    this.extraHeaders = extraHeaders;
+  }
+
+  /** @private */
+  _endpoint(key) {
+    const p = this.paths[key] || '';
+    return this.baseUrl + p;
+  }
+
+  /** @private */
+  _headers() {
+    return Object.assign({
+      [this.authHeader]: this.authPrefix + this.apiKey,
+      'Content-Type': 'application/json',
+      'Accept': 'application/json',
+    }, this.extraHeaders);
+  }
+
+  /** @private */
+  async _post(url, body, stream = false) {
+    const opts = { method: 'POST', headers: this._headers(), body: JSON.stringify(body) };
+    if (stream) return fetch(url, opts);
+    const res = await fetch(url, opts);
+    return res.json();
+  }
+
+  /** @private */
+  async _get(url) {
+    const res = await fetch(url, { method: 'GET', headers: this._headers() });
+    return res.json();
+  }
+
+  // ─── Chat ───
+  async chat(messages, options = {}) {
+    const payload = this._buildChatPayload(messages, options);
+    const res = await this._post(this._endpoint('chat'), payload);
+    this._normalizeToolCallsOnResponse(res);
+    return res || {};
+  }
+
+  /** @private */
+  _buildChatPayload(messages, options) {
+    const payload = {
+      model: options.model || options.deployment || 'gpt-like',
+      messages,
+    };
+    this._applySamplingOptions(payload, options);
+    this._applyResponseFormatOptions(payload, options);
+    this._applyToolsOptions(payload, options);
+    return payload;
+  }
+
+  /** @private */
+  _applySamplingOptions(payload, options) {
+    for (const k of ['temperature', 'top_p', 'max_tokens', 'frequency_penalty', 'presence_penalty', 'stop', 'seed', 'user']) {
+      if (options[k] !== undefined) payload[k] = options[k];
+    }
+  }
+
+  /** @private */
+  _applyResponseFormatOptions(payload, options) {
+    if (options.response_format === 'json') {
+      const schema = (options.json_schema || {}).schema || { type: 'object' };
+      payload.response_format = {
+        type: 'json_schema',
+        json_schema: options.json_schema || { name: 'auto_schema', schema },
+      };
+    }
+  }
+
+  /** @private */
+  _applyToolsOptions(payload, options) {
+    if (!options.tools || !Array.isArray(options.tools)) return;
+    payload.tools = options.tools.map(tool => ({
+      type: 'function',
+      function: {
+        name: tool.name,
+        description: tool.description || '',
+        parameters: tool.parameters || tool.schema || { type: 'object', properties: {} },
+      },
+    }));
+    if (options.tool_choice) payload.tool_choice = options.tool_choice;
+  }
+
+  /** @private */
+  _normalizeToolCallsOnResponse(res) {
+    if (!res || !res.choices?.[0]?.message?.tool_calls) return;
+    res.tool_calls = res.choices[0].message.tool_calls.map(tc => ({
+      id: tc.id || null,
+      name: (tc.function || {}).name || null,
+      arguments: (() => { try { return JSON.parse((tc.function || {}).arguments || '{}'); } catch { return {}; } })(),
+    }));
+  }
+
+  // ─── Streaming ───
+  async *stream(messages, options = {}) {
+    const payload = { model: options.model || 'gpt-like', messages, stream: true };
+    const res = await this._post(this._endpoint('chat'), payload, true);
+    yield* this._readSse(res.body);
+  }
+
+  async *streamEvents(messages, options = {}) {
+    const payload = { model: options.model || 'gpt-like', messages, stream: true };
+    const res = await this._post(this._endpoint('chat'), payload, true);
+    for await (const delta of this._readSse(res.body)) {
+      yield { type: 'delta', data: delta };
+    }
+    yield { type: 'end', data: null };
+  }
+
+  /** @private */
+  async *_readSse(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split(/\r?\n/);
+        buffer = lines.pop() || '';
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (trimmed === '' || trimmed.startsWith(':') || !trimmed.startsWith('data:')) continue;
+          const json = trimmed.slice(5).trim();
+          if (json === '[DONE]') return;
+          try {
+            const decoded = JSON.parse(json);
+            const delta = decoded?.choices?.[0]?.delta?.content || null;
+            if (delta !== null) yield delta;
+          } catch { /* skip */ }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+
+  supportsStreaming() { return true; }
+
+  // ─── Models ───
+  async listModels() {
+    const url = this.baseUrl + this._modelsPath();
+    return (await this._get(url)) || {};
+  }
+
+  async getModel(id) {
+    const url = this.baseUrl + this._modelsPath() + '/' + encodeURIComponent(id);
+    return (await this._get(url)) || {};
+  }
+
+  /** @private */
+  _modelsPath() {
+    if (this.paths.models) return this.paths.models;
+    if (/\/v\d+(?:$|\/)/.test(this.baseUrl)) return '/models';
+    return '/v1/models';
+  }
+
+  // ─── Embeddings ───
+  async embeddings(inputs, options = {}) {
+    const payload = { model: options.model || 'embedding-model', input: inputs };
+    const res = await this._post(this._endpoint('embeddings'), payload);
+    return {
+      embeddings: (res.data || []).map(d => d.embedding || []),
+      usage: res.usage || {},
+      raw: res,
+    };
+  }
+
+  // ─── Images ───
+  async generateImage(prompt, options = {}) {
+    const payload = { prompt, model: options.model || 'image-model', n: 1 };
+    const res = await this._post(this._endpoint('image'), payload);
+    return { images: res.data || [], raw: res };
+  }
+
+  // ─── Audio ───
+  async textToSpeech(text, options = {}) {
+    const payload = {
+      model: options.model || 'tts-model',
+      input: text,
+      voice: options.voice || 'alloy',
+      format: options.format || 'mp3',
+    };
+    const res = await fetch(this._endpoint('tts'), {
+      method: 'POST',
+      headers: this._headers(),
+      body: JSON.stringify(payload),
+    });
+    const arrayBuf = await res.arrayBuffer();
+    return { audio: Buffer.from(arrayBuf).toString('base64'), mime: 'audio/mpeg' };
+  }
+
+  async speechToText(filePath, options = {}) {
+    const fs = require('fs');
+    const path = require('path');
+    const formData = new FormData();
+    const fileBuffer = fs.readFileSync(filePath);
+    const blob = new Blob([fileBuffer], { type: 'application/octet-stream' });
+    formData.append('file', blob, path.basename(filePath));
+    formData.append('model', options.model || 'stt-model');
+    formData.append('response_format', 'json');
+
+    const headers = { [this.authHeader]: this.authPrefix + this.apiKey };
+    Object.assign(headers, this.extraHeaders);
+    const res = await fetch(this._endpoint('stt'), { method: 'POST', headers, body: formData });
+    const data = await res.json();
+    return { text: data.text || '', raw: data };
+  }
+}
+
+module.exports = CustomOpenAIProvider;

package/src/AI/Providers/GeminiProvider.js

@@ -0,0 +1,68 @@
+'use strict';
+
+/**
+ * GeminiProvider
+ * Google Generative Language API. Supports chat, simulated streaming, and embeddings.
+ */
+class GeminiProvider {
+  /**
+   * @param {string} apiKey
+   * @param {string} [chatEndpoint='https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent']
+   */
+  constructor(apiKey, chatEndpoint = 'https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent') {
+    this.apiKey = apiKey;
+    this.chatEndpoint = chatEndpoint;
+    this.embedEndpoint = 'https://generativelanguage.googleapis.com/v1beta/models/text-embedding-004:embedContent';
+  }
+
+  /** @private */
+  _keyQuery() { return `?key=${this.apiKey}`; }
+
+  async chat(messages, options = {}) {
+    const userTexts = messages
+      .filter(m => (m.role || '') !== 'system')
+      .map(m => m.content);
+
+    const payload = {
+      contents: [{ parts: [{ text: userTexts.join('\n') }] }],
+    };
+
+    const res = await fetch(this.chatEndpoint + this._keyQuery(), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+    });
+    const data = await res.json();
+    return data || {};
+  }
+
+  async *stream(messages, options = {}) {
+    const full = await this.chat(messages, options);
+    const text = full?.candidates?.[0]?.content?.parts?.[0]?.text || '';
+    for (let i = 0; i < text.length; i += 80) {
+      yield text.slice(i, i + 80);
+    }
+  }
+
+  supportsStreaming() { return true; } // simulated
+
+  async embeddings(inputs, options = {}) {
+    const vectors = [];
+    for (const input of inputs) {
+      const payload = {
+        model: 'text-embedding-004',
+        content: { parts: [{ text: input }] },
+      };
+      const res = await fetch(this.embedEndpoint + this._keyQuery(), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+      });
+      const data = await res.json();
+      vectors.push((data?.embedding || {}).values || []);
+    }
+    return { embeddings: vectors };
+  }
+}
+
+module.exports = GeminiProvider;

package/src/AI/Providers/GrokProvider.js

@@ -0,0 +1,46 @@
+'use strict';
+
+/**
+ * GrokProvider
+ * Prompt-based chat with simulated streaming (80-char chunks).
+ */
+class GrokProvider {
+  /**
+   * @param {string} apiKey
+   * @param {string} [endpoint='https://api.grok.com/v1/chat']
+   */
+  constructor(apiKey, endpoint = 'https://api.grok.com/v1/chat') {
+    this.apiKey = apiKey;
+    this.endpoint = endpoint;
+  }
+
+  async chat(messages, options = {}) {
+    const joined = messages.map(m => m.content).join('\n');
+    const payload = {
+      prompt: joined,
+      model: options.model || 'grok-default',
+    };
+    const res = await fetch(this.endpoint, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${this.apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(payload),
+    });
+    const data = await res.json();
+    return data || {};
+  }
+
+  async *stream(messages, options = {}) {
+    const full = await this.chat(messages, options);
+    const text = full.response || '';
+    for (let i = 0; i < text.length; i += 80) {
+      yield text.slice(i, i + 80);
+    }
+  }
+
+  supportsStreaming() { return true; } // simulated
+}
+
+module.exports = GrokProvider;

package/src/AI/Providers/MistralProvider.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const OpenAIProvider = require('./OpenAIProvider');
+
+/**
+ * MistralProvider
+ * Targets Mistral AI API (https://api.mistral.ai) — OpenAI-compatible endpoints.
+ */
+class MistralProvider extends OpenAIProvider {
+  /**
+   * @param {string} apiKey
+   * @param {string} [chatEndpoint='https://api.mistral.ai/v1/chat/completions']
+   */
+  constructor(apiKey, chatEndpoint = 'https://api.mistral.ai/v1/chat/completions') {
+    super(apiKey, chatEndpoint);
+    this.modelsEndpoint = 'https://api.mistral.ai/v1/models';
+    this.embeddingsEndpoint = 'https://api.mistral.ai/v1/embeddings';
+  }
+}
+
+module.exports = MistralProvider;