@hyperbytes/wappler-all-in-one-ai-v2 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hyperbytes/wappler-all-in-one-ai-v2",
-    "version": "1.0.0",
+    "version": "1.0.2",
     "description": "Versitile interface to chatGPT, Gemini Claude with file analysis cababilities",
     "license": "MIT",
     "author": {
@@ -19,7 +19,7 @@
         "openai": "^6.15.0",
         "sharp": "^0.34.5",
         "xlsx": "^0.18.5",
-        "pdf-parse2": "^2.4.5",
+        "pdf-parse": "^2.4.5",
         "path": "^0.12.7"
     }
 }

package/server_connect/modules/multiaiv2.hjson

@@ -0,0 +1,117 @@
+{
+  type: 'multiaiv2_multiaiv2',
+  module : 'multiaiv2',
+  action : 'multiaiv2',
+  groupTitle : 'AI Modules',
+  groupIcon : 'fas fa-solid fa-brain comp-loops',
+  title : 'Multi AI Module V2',
+  icon : 'fas fa-brands fa-brain comp-loops',
+     serverModel : ['node'],
+    dataPickObject: true,
+            dataScheme: [
+    {name: 'result', type: 'text'},
+     ],
+  usedModules : {
+    node: {
+      '@anthropic-ai/sdk' : '^0.71.2',
+      '@google/generative-ai' : '^0.24.1',
+      'openai': '^6.15.0',
+      'sharp': '^0.34.5',
+      'xlsx': '^0.18.5',
+      'pdf-parse':'^2.4.5',
+      'path':'^0.12.7'
+
+    }
+  }
+  properties : [
+    {
+      group: 'Input Question',
+      variables: [
+        { name: 'actionName', 
+        optionName: 'name', 
+        title: 'Name', 
+        type: 'text', 
+        required: true, 
+        defaultValue: '',
+        baseName: "multiAI1"
+        },
+         { name: 'mytraining', 
+        optionName: 'mytraining', 
+        title: 'Training Info', 
+        type: 'textarea', 
+        required: true, 
+        defaultValue: '',
+        serverDataBindings: true,
+        help: 'Info about the user to train the AI on, use dynamic data if you can, to improve the UX'
+        },
+        { name: 'question', 
+        optionName: 'question', 
+        title: 'AI Question', 
+        type: 'text', 
+        required: true, 
+        defaultValue: '',
+        serverDataBindings: true,
+        help: 'The question you wish to ask'
+        },
+        { name: 'maxtokens', 
+          optionName: 'maxtokens', 
+          title: 'Maximum tokens', 
+          type: 'text', 
+          required: false,
+          serverDataBindings: true,
+           help: 'The maximum number of tokens to use'
+           },
+           { name: 'temperature', 
+          optionName: 'temperature', 
+          title: 'temperature', 
+          type: 'text', 
+          required: false,
+          defaultValue: ".5", 
+           serverDataBindings: true,
+           help: 'The temperature'
+           },
+        { name: 'engine', optionName: 'engine', title: 'Engine', 
+  type: 'droplist', 
+  values: [
+    {title: 'claude-3-5-sonnet-', value: 'claude-3-5-sonnet-latest' },
+    {title: 'claude-3-opus', value: 'claude-3-opus-20240229' }, 
+    {title: 'claude-3.5-haiku Latest', value: 'claude-3.5-haiku-latest' },
+    {title: 'claude-3.7-Sonnet', value: 'claude-3.7-sonnet' },
+    {title: 'claude-4-5-Sonnet', value: 'claude-sonnet-4-5' },
+    {title: 'claude-4-5-Haiku', value: 'claude-haiku-4-5' },
+    {title: 'claude-4-5-Opus', value: 'claude-opus-4-5' },
+    {title: 'claude-4-5-Sonnet-20250929', value: 'claude-sonnet-4-5' },
+    {title: 'Gemini 1.5 Pro', value: 'gemini-1.5-pro-latest' },
+    {title: 'Gemini 2.0 Flash', value: 'gemini-2.0-flash' },
+    {title: 'Gemini 2.5 Pro', value: 'gemini-2.0-pro' },
+    {title: 'Deepseek Reasoner', value: 'deepseek-reasoner' },
+    {title: 'Deepseek v3', value: 'deepseek-v3' },
+    {title: 'deepseek v3 vision', value: 'deepseek-v3-vision' },
+    {title: 'gpt-4o-mini', value: 'gpt-4o-mini' },
+    {title: 'gpt-4o ', value: 'gpt-4o' },
+    {title: 'gpt-4.1', value: 'gpt-4.1' },
+    {title: 'gpt-5', value: 'gpt-5' },
+    {title: 'gpt-5 mini', value: 'gpt-5-mini' },
+    {title: 'gpt-5 nano', value: 'gpt-5-nano' }
+  ],
+	help: 'Choose your AI service'
+},
+             { name: 'image_url', 
+          optionName: 'image_url', 
+          title: 'Upload File', 
+          type: 'file', 
+          required: false,
+           serverDataBindings: true,
+           help: 'File to upload'
+           },      
+{ name: 'output', 
+          optionName: 'output', 
+          title: 'Output', 
+          type: 'boolean', 
+          defaultValue: false 
+          }
+      ]
+    },
+   
+  ]
+}

package/server_connect/modules/multiaiv2.js

@@ -0,0 +1,170 @@
+const { OpenAI } = require('openai');
+const { GoogleGenerativeAI } = require('@google/generative-ai');
+const Anthropic = require('@anthropic-ai/sdk');
+const fs = require('fs');
+const path = require('path');
+const XLSX = require('xlsx');
+const pdf = require('pdf-parse');
+const sharp = require('sharp');
+
+const clamp = (val, min, max) => Math.max(min, Math.min(max, val));
+
+/**
+ * HELPER: Compresses and converts image to Base64
+ */
+async function getCompressedImageBase64(filePath) {
+    try {
+        const fullPath = path.join(process.cwd(), filePath);
+        console.log("Checking for image at:", fullPath);
+
+        if (!fs.existsSync(fullPath)) {
+            console.error("FILE NOT FOUND:", fullPath);
+            return null;
+        }
+
+        const buffer = await sharp(fullPath)
+            .resize(1500, 1500, { fit: 'inside', withoutEnlargement: true })
+            .jpeg({ quality: 80 })
+            .toBuffer();
+
+        console.log("Image compressed successfully. Size:", (buffer.length / 1024).toFixed(2), "KB");
+        return `data:image/jpeg;base64,${buffer.toString('base64')}`;
+    } catch (err) {
+        console.error("Sharp Compression Error:", err.message);
+        return null;
+    }
+}
+
+/**
+ * HELPER: Extract text from Docs
+ */
+async function getFileContent(filePath) {
+    try {
+        const fullPath = path.join(process.cwd(), filePath);
+        if (!fs.existsSync(fullPath)) return null;
+        const ext = path.extname(fullPath).toLowerCase();
+
+        if (ext === '.txt' || ext === '.csv') return fs.readFileSync(fullPath, 'utf8');
+        if (ext === '.xlsx' || ext === '.xls') {
+            const wb = XLSX.readFile(fullPath);
+            return XLSX.utils.sheet_to_csv(wb.Sheets[wb.SheetNames[0]]);
+        }
+        if (ext === '.pdf') {
+            const data = await pdf(fs.readFileSync(fullPath));
+            return data.text;
+        }
+    } catch (e) { return null; }
+    return null;
+}
+
+exports.multiaiv2 = async function (options) {
+    let question = this.parseRequired(options.question, "*", 'No Question passed');
+    const engine = this.parse(options.engine) || 'gpt-4o-mini';
+    const maxTokens = parseInt(this.parseOptional(options.maxtokens, "*", 2000));
+    const temp = parseFloat(this.parseOptional(options.temperature, "*", 0.7));
+    const fileInput = this.parse(options.image_url);
+
+    const modelName = engine.toLowerCase();
+    const isReasoningModel = modelName.includes('gpt-5') || modelName.startsWith('o1') || modelName.startsWith('o3');
+
+    console.log(`Starting Request - Model: ${engine}, File: ${fileInput}`);
+
+    // 1. Pre-process Docs (Injection)
+    if (fileInput && /\.(pdf|xlsx|xls|txt|csv)$/i.test(fileInput)) {
+        const text = await getFileContent(fileInput);
+        if (text) {
+            question += `\n\n[FILE CONTENT]:\n${text}`;
+            console.log("Document text injected into prompt.");
+        }
+    }
+
+    try {
+        // --- OpenAI (GPT-4o, GPT-5, o1) ---
+        if (modelName.includes('gpt') || modelName.includes('o1') || modelName.includes('o3')) {
+            const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+
+            let userContent = [{ type: "text", text: question }];
+
+            if (fileInput && /\.(jpg|jpeg|png|webp)$/i.test(fileInput) && !isReasoningModel) {
+                const b64 = await getCompressedImageBase64(fileInput);
+                if (b64) {
+                    userContent.push({
+                        type: "image_url",
+                        image_url: { url: b64, detail: "high" }
+                    });
+                    console.log("Image successfully attached to OpenAI payload.");
+                }
+            }
+
+            const payload = {
+                model: engine,
+                messages: [{ role: 'user', content: userContent }]
+            };
+
+            if (isReasoningModel) {
+                payload.max_completion_tokens = Math.max(maxTokens, 5000);
+            } else {
+                payload.max_tokens = maxTokens;
+                payload.temperature = clamp(temp, 0, 2);
+            }
+
+            const res = await client.chat.completions.create(payload);
+            return { 'result': res.choices[0].message.content };
+        }
+
+        // --- Gemini ---
+        if (modelName.includes('gemini')) {
+            const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);
+            const model = genAI.getGenerativeModel({ model: engine });
+            const promptParts = [{ text: question }];
+
+            if (fileInput && /\.(jpg|jpeg|png|webp)$/i.test(fileInput)) {
+                const b64 = await getCompressedImageBase64(fileInput);
+                if (b64) {
+                    promptParts.push({
+                        inlineData: {
+                            data: b64.split(',')[1],
+                            mimeType: "image/jpeg"
+                        }
+                    });
+                    console.log("Image successfully attached to Gemini payload.");
+                }
+            }
+
+            const result = await model.generateContent({ contents: [{ role: 'user', parts: promptParts }] });
+            return { 'result': result.response.text() };
+        }
+
+        // --- Claude ---
+        if (modelName.includes('claude')) {
+            const anthropic = new Anthropic({ apiKey: process.env.CLAUDE_API_KEY });
+            const messageParts = [{ type: "text", text: question }];
+
+            if (fileInput && /\.(jpg|jpeg|png|webp)$/i.test(fileInput)) {
+                const b64 = await getCompressedImageBase64(fileInput);
+                if (b64) {
+                    messageParts.push({
+                        type: "image",
+                        source: {
+                            type: "base64",
+                            media_type: "image/jpeg",
+                            data: b64.split(',')[1]
+                        }
+                    });
+                    console.log("Image successfully attached to Claude payload.");
+                }
+            }
+
+            const res = await anthropic.messages.create({
+                model: engine,
+                max_tokens: maxTokens,
+                messages: [{ role: 'user', content: messageParts }],
+            });
+            return { "result": res.content[0].text };
+        }
+
+    } catch (e) {
+        console.error("API Call failed:", e.message);
+        throw new Error(`AI Extension Error: ${e.message}`);
+    }
+};