let-them-talk 5.3.0 → 5.4.1

package/providers/dalle.js

@@ -0,0 +1,79 @@
+// DALL-E 3 provider adapter (Phase 5 — placeholder)
+const https = require('https');
+
+class DalleProvider {
+  constructor(options = {}) {
+    this.apiKey = options.apiKey || '';
+    this.model = options.model || 'dall-e-3';
+    this.size = options.size || '1024x1024';
+    this.quality = options.quality || 'standard';
+    this.name = 'dalle';
+    this.color = '#10b981'; // green
+  }
+
+  async generate(prompt, options = {}) {
+    if (!this.apiKey) throw new Error('DALL-E API key not configured');
+
+    const body = JSON.stringify({
+      model: this.model,
+      prompt: prompt,
+      n: 1,
+      size: options.size || this.size,
+      quality: options.quality || this.quality,
+      response_format: 'b64_json',
+    });
+
+    return new Promise((resolve, reject) => {
+      const req = https.request({
+        hostname: 'api.openai.com',
+        path: '/v1/images/generations',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.apiKey}`,
+        },
+        timeout: 120000,
+      }, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          try {
+            const result = JSON.parse(data);
+            if (result.error) {
+              reject(new Error(result.error.message || 'DALL-E API error'));
+              return;
+            }
+            if (result.data && result.data[0]) {
+              resolve({
+                type: 'image',
+                data: result.data[0].b64_json,
+                format: 'png',
+                model: this.model,
+                prompt: prompt,
+                revised_prompt: result.data[0].revised_prompt,
+              });
+            } else {
+              reject(new Error('No image data in response'));
+            }
+          } catch (e) {
+            reject(new Error('Failed to parse DALL-E response: ' + e.message));
+          }
+        });
+      });
+      req.on('error', (e) => reject(new Error('DALL-E connection failed: ' + e.message)));
+      req.on('timeout', () => { req.destroy(); reject(new Error('DALL-E request timed out')); });
+      req.write(body);
+      req.end();
+    });
+  }
+
+  async checkHealth() {
+    return !!this.apiKey;
+  }
+
+  async listModels() {
+    return [{ name: 'dall-e-3', size: 'cloud' }, { name: 'dall-e-2', size: 'cloud' }];
+  }
+}
+
+module.exports = { DalleProvider };

package/providers/gemini.js

@@ -0,0 +1,181 @@
+// Gemini API provider — text + image generation via Google's REST API
+// Supports gemini-2.5-flash-image and gemini-3.1-flash-image-preview models
+// Uses raw HTTP (no SDK dependency) for maximum compatibility
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+
+const API_HOST = 'generativelanguage.googleapis.com';
+const API_BASE = '/v1beta/models/';
+
+class GeminiProvider {
+  constructor(options = {}) {
+    this.apiKey = options.apiKey || '';
+    this.model = options.model || 'gemini-3-pro-image-preview';
+    this.name = 'gemini';
+    this.color = '#4285f4'; // Google blue
+  }
+
+  async generate(prompt, options = {}) {
+    if (!this.apiKey) throw new Error('Gemini API key not configured');
+
+    var aspectRatio = options.aspectRatio || '16:9';
+
+    // Build request parts — text + optional input images
+    var parts = [{ text: prompt }];
+
+    // Add input images if provided (for image-to-image / style reference)
+    if (options.images && Array.isArray(options.images)) {
+      for (var ii = 0; ii < options.images.length; ii++) {
+        var img = options.images[ii];
+        if (img.base64 && img.mimeType) {
+          parts.push({
+            inlineData: {
+              mimeType: img.mimeType,
+              data: img.base64,
+            }
+          });
+        }
+      }
+    }
+
+    var body = {
+      contents: [{ parts: parts }],
+      generationConfig: {
+        responseModalities: ['TEXT', 'IMAGE'],
+        imageConfig: {
+          aspectRatio: aspectRatio,
+        }
+      }
+    };
+
+    // gemini-3.x models support imageSize — default to highest quality
+    if (this.model.indexOf('gemini-3') === 0) {
+      body.generationConfig.imageConfig.imageSize = options.imageSize || '4K';
+    }
+
+    var bodyStr = JSON.stringify(body);
+    var apiPath = API_BASE + this.model + ':generateContent';
+    var self = this;
+
+    return new Promise(function(resolve, reject) {
+      var req = https.request({
+        hostname: API_HOST,
+        path: apiPath,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'x-goog-api-key': self.apiKey,
+        },
+        timeout: 180000, // 3 min — image gen can be slow
+      }, function(res) {
+        var data = '';
+        res.on('data', function(chunk) { data += chunk; });
+        res.on('end', function() {
+          try {
+            var result = JSON.parse(data);
+
+            // Check for API errors
+            if (result.error) {
+              reject(new Error('Gemini API error: ' + (result.error.message || JSON.stringify(result.error))));
+              return;
+            }
+
+            // Parse response — look for image parts
+            if (!result.candidates || !result.candidates[0] || !result.candidates[0].content) {
+              reject(new Error('No content in Gemini response'));
+              return;
+            }
+
+            var parts = result.candidates[0].content.parts || [];
+            var imageData = null;
+            var mimeType = 'image/png';
+            var textResponse = '';
+
+            for (var i = 0; i < parts.length; i++) {
+              var part = parts[i];
+              if (part.inlineData && part.inlineData.data) {
+                imageData = part.inlineData.data; // base64
+                mimeType = part.inlineData.mimeType || 'image/png';
+              } else if (part.text) {
+                textResponse += part.text;
+              }
+            }
+
+            if (imageData) {
+              // Determine file extension from mime type
+              var ext = 'png';
+              if (mimeType.indexOf('jpeg') !== -1 || mimeType.indexOf('jpg') !== -1) ext = 'jpg';
+              else if (mimeType.indexOf('webp') !== -1) ext = 'webp';
+
+              resolve({
+                type: 'image',
+                data: imageData,
+                format: ext,
+                model: self.model,
+                prompt: prompt,
+                revised_prompt: textResponse || null,
+              });
+            } else if (textResponse) {
+              // Text-only response (no image generated)
+              resolve({
+                type: 'text',
+                data: textResponse,
+                model: self.model,
+                prompt: prompt,
+              });
+            } else {
+              reject(new Error('Empty response from Gemini — no image or text returned'));
+            }
+          } catch (e) {
+            reject(new Error('Failed to parse Gemini response: ' + e.message));
+          }
+        });
+      });
+
+      req.on('error', function(e) {
+        reject(new Error('Gemini connection failed: ' + e.message));
+      });
+      req.on('timeout', function() {
+        req.destroy();
+        reject(new Error('Gemini request timed out (180s)'));
+      });
+      req.write(bodyStr);
+      req.end();
+    });
+  }
+
+  async checkHealth() {
+    if (!this.apiKey) return false;
+    // Quick check: list models endpoint
+    var self = this;
+    return new Promise(function(resolve) {
+      var req = https.request({
+        hostname: API_HOST,
+        path: '/v1beta/models?key=' + self.apiKey,
+        method: 'GET',
+        timeout: 10000,
+      }, function(res) {
+        var data = '';
+        res.on('data', function(chunk) { data += chunk; });
+        res.on('end', function() {
+          resolve(res.statusCode === 200);
+        });
+      });
+      req.on('error', function() { resolve(false); });
+      req.on('timeout', function() { req.destroy(); resolve(false); });
+      req.end();
+    });
+  }
+
+  async listModels() {
+    return [
+      { name: 'gemini-3-pro-image-preview', size: 'cloud', description: 'Pro quality, 4K, Nano Banana' },
+      { name: 'gemini-3.1-flash-image-preview', size: 'cloud', description: 'Fast, supports 2K + imageSize' },
+      { name: 'gemini-2.5-flash-image', size: 'cloud', description: 'Legacy fast image generation' },
+    ];
+  }
+}
+
+module.exports = { GeminiProvider };

package/providers/ollama.js

@@ -0,0 +1,184 @@
+// Ollama provider adapter for local AI model inference
+// Supports text-to-image models (SDXL, Flux, etc.) and vision models
+
+const http = require('http');
+const https = require('https');
+
+class OllamaProvider {
+  constructor(options = {}) {
+    this.endpoint = options.endpoint || 'http://localhost:11434';
+    this.model = options.model || 'sdxl';
+    this.name = 'ollama';
+    this.color = '#0ea5e9'; // blue
+  }
+
+  async generate(prompt, options = {}) {
+    const url = new URL(this.endpoint);
+    const isHttps = url.protocol === 'https:';
+    const transport = isHttps ? https : http;
+
+    // Try image generation first (for models that support it)
+    const imageResult = await this._tryImageGeneration(transport, url, prompt, options);
+    if (imageResult) return imageResult;
+
+    // Fallback: use chat completion with image description
+    return this._textGeneration(transport, url, prompt, options);
+  }
+
+  async _tryImageGeneration(transport, url, prompt, options) {
+    // Ollama doesn't have a native image generation API yet,
+    // but some setups expose it via compatible endpoints.
+    // Try the /api/generate endpoint with image-capable models
+    const body = JSON.stringify({
+      model: this.model,
+      prompt: prompt,
+      stream: false,
+      options: {
+        num_predict: options.maxTokens || 4096,
+      }
+    });
+
+    return new Promise((resolve) => {
+      const req = transport.request({
+        hostname: url.hostname,
+        port: url.port || (url.protocol === 'https:' ? 443 : 11434),
+        path: '/api/generate',
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        timeout: 120000,
+      }, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          try {
+            const result = JSON.parse(data);
+            // Check if response contains base64 image data
+            if (result.images && result.images.length > 0) {
+              resolve({
+                type: 'image',
+                data: result.images[0], // base64
+                format: 'png',
+                model: this.model,
+                prompt: prompt,
+              });
+            } else if (result.response) {
+              // Text-only response — model doesn't generate images
+              resolve({
+                type: 'text',
+                data: result.response,
+                model: this.model,
+                prompt: prompt,
+              });
+            } else {
+              resolve(null);
+            }
+          } catch {
+            resolve(null);
+          }
+        });
+      });
+      req.on('error', () => resolve(null));
+      req.on('timeout', () => { req.destroy(); resolve(null); });
+      req.write(body);
+      req.end();
+    });
+  }
+
+  async _textGeneration(transport, url, prompt, options) {
+    const body = JSON.stringify({
+      model: this.model,
+      prompt: `Generate a detailed visual description for: ${prompt}`,
+      stream: false,
+    });
+
+    return new Promise((resolve, reject) => {
+      const req = transport.request({
+        hostname: url.hostname,
+        port: url.port || (url.protocol === 'https:' ? 443 : 11434),
+        path: '/api/generate',
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        timeout: 120000,
+      }, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          try {
+            const result = JSON.parse(data);
+            resolve({
+              type: 'text',
+              data: result.response || 'No response from model',
+              model: this.model,
+              prompt: prompt,
+            });
+          } catch (e) {
+            reject(new Error('Failed to parse Ollama response: ' + e.message));
+          }
+        });
+      });
+      req.on('error', (e) => reject(new Error('Ollama connection failed: ' + e.message)));
+      req.on('timeout', () => { req.destroy(); reject(new Error('Ollama request timed out')); });
+      req.write(body);
+      req.end();
+    });
+  }
+
+  async listModels() {
+    const url = new URL(this.endpoint);
+    const isHttps = url.protocol === 'https:';
+    const transport = isHttps ? https : http;
+
+    return new Promise((resolve) => {
+      const req = transport.request({
+        hostname: url.hostname,
+        port: url.port || (url.protocol === 'https:' ? 443 : 11434),
+        path: '/api/tags',
+        method: 'GET',
+        timeout: 10000,
+      }, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          try {
+            const result = JSON.parse(data);
+            resolve((result.models || []).map(m => ({
+              name: m.name,
+              size: m.size,
+              modified: m.modified_at,
+            })));
+          } catch {
+            resolve([]);
+          }
+        });
+      });
+      req.on('error', () => resolve([]));
+      req.on('timeout', () => { req.destroy(); resolve([]); });
+      req.end();
+    });
+  }
+
+  async checkHealth() {
+    const url = new URL(this.endpoint);
+    const isHttps = url.protocol === 'https:';
+    const transport = isHttps ? https : http;
+
+    return new Promise((resolve) => {
+      const req = transport.request({
+        hostname: url.hostname,
+        port: url.port || (url.protocol === 'https:' ? 443 : 11434),
+        path: '/',
+        method: 'GET',
+        timeout: 5000,
+      }, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => resolve(res.statusCode === 200));
+      });
+      req.on('error', () => resolve(false));
+      req.on('timeout', () => { req.destroy(); resolve(false); });
+      req.end();
+    });
+  }
+}
+
+module.exports = { OllamaProvider };

package/providers/replicate.js

@@ -0,0 +1,115 @@
+// Replicate provider adapter (Phase 5 — placeholder for Flux, Wan, SD)
+const https = require('https');
+
+class ReplicateProvider {
+  constructor(options = {}) {
+    this.apiKey = options.apiKey || '';
+    this.model = options.model || 'stability-ai/sdxl';
+    this.name = 'replicate';
+    this.color = '#8b5cf6'; // purple
+  }
+
+  async generate(prompt, options = {}) {
+    if (!this.apiKey) throw new Error('Replicate API key not configured');
+
+    const body = JSON.stringify({
+      version: this._getVersion(),
+      input: { prompt: prompt, ...options },
+    });
+
+    // Create prediction
+    const prediction = await new Promise((resolve, reject) => {
+      const req = https.request({
+        hostname: 'api.replicate.com',
+        path: '/v1/predictions',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Token ${this.apiKey}`,
+        },
+        timeout: 30000,
+      }, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          try {
+            resolve(JSON.parse(data));
+          } catch (e) {
+            reject(new Error('Failed to parse Replicate response'));
+          }
+        });
+      });
+      req.on('error', (e) => reject(new Error('Replicate connection failed: ' + e.message)));
+      req.on('timeout', () => { req.destroy(); reject(new Error('Replicate request timed out')); });
+      req.write(body);
+      req.end();
+    });
+
+    if (prediction.error) throw new Error(prediction.error.detail || 'Replicate error');
+
+    // Poll for completion
+    const result = await this._pollResult(prediction.urls.get);
+    if (result.output && result.output.length > 0) {
+      return {
+        type: 'image',
+        data: result.output[0], // URL
+        format: 'url',
+        model: this.model,
+        prompt: prompt,
+      };
+    }
+    throw new Error('No output from Replicate');
+  }
+
+  async _pollResult(url, maxAttempts = 60) {
+    for (let i = 0; i < maxAttempts; i++) {
+      await new Promise(r => setTimeout(r, 2000));
+      const result = await new Promise((resolve, reject) => {
+        const parsedUrl = new URL(url);
+        const req = https.request({
+          hostname: parsedUrl.hostname,
+          path: parsedUrl.pathname,
+          method: 'GET',
+          headers: { 'Authorization': `Token ${this.apiKey}` },
+          timeout: 10000,
+        }, (res) => {
+          let data = '';
+          res.on('data', chunk => data += chunk);
+          res.on('end', () => {
+            try { resolve(JSON.parse(data)); } catch { reject(new Error('Parse error')); }
+          });
+        });
+        req.on('error', reject);
+        req.on('timeout', () => { req.destroy(); reject(new Error('Poll timeout')); });
+        req.end();
+      });
+      if (result.status === 'succeeded') return result;
+      if (result.status === 'failed' || result.status === 'canceled') {
+        throw new Error('Replicate prediction ' + result.status);
+      }
+    }
+    throw new Error('Replicate prediction timed out');
+  }
+
+  _getVersion() {
+    const versions = {
+      'stability-ai/sdxl': '39ed52f2a78e934b3ba6e2a89f5b1c712de7dfea535525255b1aa35c5565e08b',
+      'black-forest-labs/flux': 'latest',
+    };
+    return versions[this.model] || 'latest';
+  }
+
+  async checkHealth() {
+    return !!this.apiKey;
+  }
+
+  async listModels() {
+    return [
+      { name: 'stability-ai/sdxl', size: 'cloud' },
+      { name: 'black-forest-labs/flux-schnell', size: 'cloud' },
+      { name: 'black-forest-labs/flux-dev', size: 'cloud' },
+    ];
+  }
+}
+
+module.exports = { ReplicateProvider };