jsdecryptor 4.0.3

package/davelib/wordchain.js

@@ -0,0 +1,121 @@
+class WordChainGame {
+    constructor(hostId) {
+        this.host = hostId;
+        this.players = [hostId];
+        this.scores = {};
+        this.scores[hostId] = 0;
+        this.usedWords = new Set();
+        this.currentPlayerIndex = 0;
+        this.lastWord = null;
+        this.state = 'WAITING';
+        this.rounds = 0;
+        this.maxInactivity = 60000;
+        this.createdAt = Date.now();
+    }
+
+    addPlayer(playerId) {
+        if (this.players.includes(playerId)) return false;
+        if (this.state !== 'WAITING') return false;
+        this.players.push(playerId);
+        this.scores[playerId] = 0;
+        return true;
+    }
+
+    start() {
+        if (this.players.length < 2) return false;
+        this.state = 'PLAYING';
+        this.currentPlayerIndex = 0;
+        return true;
+    }
+
+    get currentPlayer() {
+        return this.players[this.currentPlayerIndex];
+    }
+
+    submitWord(playerId, word) {
+        if (this.state !== 'PLAYING') return { ok: false, reason: 'Game not active' };
+        if (playerId !== this.currentPlayer) return { ok: false, reason: 'Not your turn' };
+
+        word = word.toLowerCase().trim();
+
+        if (word.length < 2) return { ok: false, reason: 'Word must be at least 2 letters' };
+        if (this.usedWords.has(word)) return { ok: false, reason: 'Word already used!' };
+        if (this.lastWord) {
+            const lastChar = this.lastWord.charAt(this.lastWord.length - 1);
+            if (word.charAt(0) !== lastChar) {
+                return { ok: false, reason: `Word must start with "${lastChar.toUpperCase()}"` };
+            }
+        }
+
+        this.usedWords.add(word);
+        this.lastWord = word;
+        this.scores[playerId] = (this.scores[playerId] || 0) + word.length;
+        this.rounds++;
+        this.currentPlayerIndex = (this.currentPlayerIndex + 1) % this.players.length;
+
+        return { ok: true, nextPlayer: this.currentPlayer, word };
+    }
+
+    eliminateCurrentPlayer() {
+        const eliminated = this.players.splice(this.currentPlayerIndex, 1)[0];
+        if (this.currentPlayerIndex >= this.players.length) {
+            this.currentPlayerIndex = 0;
+        }
+        if (this.players.length <= 1) {
+            this.state = 'ENDED';
+        }
+        return eliminated;
+    }
+
+    getScoreboard() {
+        return Object.entries(this.scores)
+            .sort((a, b) => b[1] - a[1])
+            .map(([player, score], i) => `${i + 1}. @${player.split(':')[0].split('@')[0]}: ${score} pts`)
+            .join('\n');
+    }
+
+    get winner() {
+        if (this.players.length === 1) return this.players[0];
+        return null;
+    }
+
+    static findAIWord(lastChar, usedWords) {
+        const commonWords = {
+            'a': ['apple', 'arrow', 'angel', 'animal', 'anchor', 'album', 'atom', 'acid', 'azure'],
+            'b': ['banana', 'bridge', 'bottle', 'butter', 'brain', 'beach', 'blood', 'brave'],
+            'c': ['cat', 'castle', 'crown', 'chain', 'cloud', 'coral', 'cream', 'click'],
+            'd': ['dog', 'dream', 'dance', 'door', 'drum', 'dusk', 'drift', 'delta'],
+            'e': ['eagle', 'earth', 'energy', 'extra', 'echo', 'ember', 'eleven', 'event'],
+            'f': ['fish', 'flame', 'forest', 'friend', 'frost', 'flash', 'fruit', 'field'],
+            'g': ['grape', 'garden', 'ghost', 'green', 'glass', 'globe', 'grain', 'gear'],
+            'h': ['house', 'heart', 'honey', 'horse', 'hello', 'hunter', 'hammer', 'haze'],
+            'i': ['island', 'iron', 'ivory', 'igloo', 'image', 'input', 'index', 'ice'],
+            'j': ['jungle', 'jewel', 'juice', 'jacket', 'jazz', 'jolly', 'junior', 'jest'],
+            'k': ['king', 'knife', 'knight', 'kite', 'kernel', 'karma', 'knot', 'keen'],
+            'l': ['lion', 'light', 'lemon', 'lake', 'lunar', 'lotus', 'letter', 'lime'],
+            'm': ['moon', 'magic', 'music', 'mouse', 'maple', 'mirror', 'metal', 'mint'],
+            'n': ['night', 'nature', 'noble', 'north', 'nest', 'needle', 'nerve', 'note'],
+            'o': ['ocean', 'orange', 'orbit', 'olive', 'onion', 'opera', 'opal', 'oven'],
+            'p': ['planet', 'pearl', 'piano', 'python', 'price', 'plant', 'power', 'pulse'],
+            'q': ['queen', 'quest', 'quiet', 'quilt', 'quartz', 'quick', 'quote', 'quiz'],
+            'r': ['river', 'rainbow', 'rocket', 'rose', 'rain', 'robot', 'ridge', 'rust'],
+            's': ['star', 'stone', 'snake', 'storm', 'sugar', 'silver', 'sand', 'sword'],
+            't': ['tiger', 'tower', 'train', 'tree', 'table', 'torch', 'tulip', 'trail'],
+            'u': ['umbrella', 'unicorn', 'ultra', 'unity', 'urban', 'upper', 'usual', 'under'],
+            'v': ['violet', 'voice', 'valley', 'venom', 'verse', 'vault', 'vivid', 'vine'],
+            'w': ['water', 'world', 'winter', 'whale', 'wind', 'wizard', 'wolf', 'wave'],
+            'x': ['xenon', 'xerox', 'xylophone'],
+            'y': ['yellow', 'yacht', 'yarn', 'youth', 'yield', 'yonder'],
+            'z': ['zebra', 'zero', 'zone', 'zenith', 'zodiac', 'zephyr', 'zinc'],
+        };
+
+        const words = commonWords[lastChar] || [];
+        const available = words.filter(w => !usedWords.has(w));
+        if (available.length > 0) {
+            return available[Math.floor(Math.random() * available.length)];
+        }
+        return null;
+    }
+}
+
+module.exports = WordChainGame;

package/daveset.js

@@ -0,0 +1,16 @@
+const settings = {
+  packname: '',
+  author: 'Davex Tech',
+  botName: "DAVE-X",
+  botOwner: 'Dave',
+  ownerNumber: '254104260236',
+  giphyApiKey: 'qnl7ssQChTdPjsKta2Ax2LMaGXz303tq',
+  commandMode: "public",
+  maxStoreMessages: 5,
+  storeWriteInterval: 60000,
+  description: "DAVE-X - Advanced WhatsApp Bot",
+  version: "4.0.0",
+  updateZipUrl: "https://github.com/Davex-254/DAVE-X/archive/refs/heads/main.zip",
+};
+
+module.exports = settings;

package/davexcore/ai/ai.js

@@ -0,0 +1,100 @@
+const axios = require('axios');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+const GPT_API = {
+    baseURL: "https://iamtkm.vercel.app",
+    endpoint: "/ai/gpt5",
+    apiKey: "tkm"
+};
+
+async function aiCommand(sock, chatId, message) {
+    try {
+        const fake = createFakeContact(message);
+        const botName = getBotName();
+        const text = message.message?.conversation || 
+                    message.message?.extendedTextMessage?.text;
+
+        if (!text) {
+            return await sock.sendMessage(chatId, { 
+                text: `✦ AI Assistant\n\nUse: .ai [your question]\nExample: .ai explain machine learning` 
+            }, { quoted: fake });
+        }
+
+        const parts = text.split(' ');
+        const query = parts.slice(1).join(' ').trim();
+
+        if (!query) {
+            return await sock.sendMessage(chatId, { 
+                text: `✦ Need a question after .ai\n\nExample: .ai what is AI` 
+            }, { quoted: fake });
+        }
+
+        await sock.sendMessage(chatId, {
+            react: { text: '⚡', key: message.key }
+        });
+
+        await processAIRequest(sock, chatId, message, query);
+
+    } catch (error) {
+        console.error('AI Command Error:', error);
+        const fake = createFakeContact(message);
+        await sock.sendMessage(chatId, {
+            text: `✦ AI service down. Try again later.`
+        }, { quoted: fake });
+    }
+}
+
+async function processAIRequest(sock, chatId, message, query) {
+    try {
+        const fake = createFakeContact(message);
+        const apiUrl = `${GPT_API.baseURL}${GPT_API.endpoint}?apikey=${GPT_API.apiKey}&text=${encodeURIComponent(query)}`;
+        
+        const response = await axios.get(apiUrl, { 
+            timeout: 30000,
+            headers: {
+                'User-Agent': 'WhatsApp-Bot/1.0',
+                'Accept': 'application/json'
+            }
+        });
+        
+        const data = response.data;
+        
+        if (data.status && data.statusCode === 200 && data.result) {
+            await sock.sendMessage(chatId, {
+                text: data.result
+            }, { quoted: fake });
+            
+            await sock.sendMessage(chatId, {
+                react: { text: '✅', key: message.key }
+            });
+        } else {
+            await sock.sendMessage(chatId, {
+                text: `✦ AI couldn't generate a response. Try a different question.`
+            }, { quoted: fake });
+        }
+
+    } catch (error) {
+        console.error('AI API Error:', error.message);
+        const fake = createFakeContact(message);
+        
+        if (error.response?.status === 429) {
+            await sock.sendMessage(chatId, {
+                text: `✦ Rate limit. Wait 5 minutes.`
+            }, { quoted: fake });
+        } else if (error.code === 'ECONNABORTED' || error.code === 'ETIMEDOUT') {
+            await sock.sendMessage(chatId, {
+                text: `✦ Request timeout. Try shorter question.`
+            }, { quoted: fake });
+        } else {
+            await sock.sendMessage(chatId, {
+                text: `✦ AI service error. Try later.`
+            }, { quoted: fake });
+        }
+
+        await sock.sendMessage(chatId, {
+            react: { text: '❌', key: message.key }
+        });
+    }
+}
+
+module.exports = aiCommand;

package/davexcore/ai/aiGpt4.js

@@ -0,0 +1,59 @@
+const axios = require('axios');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+async function gpt4Command(sock, chatId, message) {
+  const botName = getBotName();
+  try {
+    const text = message.message?.conversation || 
+                 message.message?.extendedTextMessage?.text || 
+                 message.text;
+
+    if (!text) {
+      const fake = createFakeContact(message);
+      return sock.sendMessage(chatId, { text: `*${botName}*\nType your question after the command\nExample: .ai explain quantum physics` }, { quoted: fake });
+    }
+
+    const [command, ...rest] = text.split(' ');
+    const query = rest.join(' ').trim();
+
+    if (!query) {
+      const fake = createFakeContact(message);
+      return sock.sendMessage(chatId, { text: `*${botName}*\nMissing question\nExample: .ai what is AI?` }, { quoted: fake });
+    }
+
+    await sock.sendMessage(chatId, { react: { text: '>', key: message.key } });
+    await handleAI(sock, chatId, message, query);
+
+  } catch (err) {
+    console.error('AI Command Error:', err);
+    const fake = createFakeContact(message);
+    await sock.sendMessage(chatId, { text: `*${botName}*\nAI service error` }, { quoted: fake });
+  }
+}
+
+async function handleAI(sock, chatId, message, query) {
+  const botName = getBotName();
+  const fake = createFakeContact(message);
+  
+  const apis = [
+    { url: `https://bk9.fun/ai/GPT4o?q=${encodeURIComponent(query)}`, parse: d => d.BK9 || d.result },
+    { url: `https://api.dreaded.site/api/chatgpt?text=${encodeURIComponent(query)}`, parse: d => d.result },
+    { url: `https://iamtkm.vercel.app/ai/gpt5?apikey=tkm&text=${encodeURIComponent(query)}`, parse: d => d.result },
+  ];
+
+  for (const api of apis) {
+    try {
+      const res = await axios.get(api.url, { timeout: 15000 });
+      const result = api.parse(res.data);
+      if (result && result.trim()) {
+        await sock.sendMessage(chatId, { text: result.substring(0, 3000) }, { quoted: fake });
+        await sock.sendMessage(chatId, { react: { text: '>', key: message.key } });
+        return;
+      }
+    } catch {}
+  }
+
+  await sock.sendMessage(chatId, { text: `*${botName}*\nAI services are currently down. Try again later.` }, { quoted: fake });
+}
+
+module.exports = gpt4Command;

package/davexcore/ai/aimodels.js

@@ -0,0 +1,284 @@
+const axios = require('axios');
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+
+// Helper function to try multiple APIs
+async function tryAPIs(apis) {
+    for (const api of apis) {
+        try {
+            let res;
+            if (api.method === 'POST') {
+                res = await axios.post(api.url, api.body, { 
+                    timeout: 15000,
+                    headers: api.headers || {} 
+                });
+            } else {
+                res = await axios.get(api.url, { 
+                    timeout: 15000,
+                    headers: api.headers || {} 
+                });
+            }
+            
+            // Handle different response formats
+            const result = api.parse(res.data);
+            if (result && typeof result === 'string' && result.trim().length > 0) {
+                return result.substring(0, 3000);
+            }
+        } catch (e) {
+            // Silently fail and try next API
+        }
+    }
+    return null;
+}
+
+// ==================== DEEPSEEK (FIXED - WORKING) ====================
+async function deepseekCommand(sock, chatId, message, args) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    const query = args.join(' ').trim();
+
+    if (!query) {
+        return sock.sendMessage(chatId, { 
+            text: `*${botName} DEEPSEEK*\n\nUsage: .deepseek <question>\nExample: .deepseek explain neural networks` 
+        }, { quoted: fake });
+    }
+
+    await sock.sendMessage(chatId, { react: { text: '🔍', key: message.key } });
+
+    // FIXED: Only working Deepseek APIs
+    const result = await tryAPIs([
+        { 
+            url: `https://api.dreaded.site/api/deepseek?text=${encodeURIComponent(query)}`, 
+            parse: d => d.response || d.result || d.message 
+        },
+        { 
+            url: `https://bk9.fun/ai/deepseek?q=${encodeURIComponent(query)}`, 
+            parse: d => d.BK9 || d.result || d.data 
+        }
+    ]);
+
+    if (result) {
+        await sock.sendMessage(chatId, { text: result }, { quoted: fake });
+        await sock.sendMessage(chatId, { react: { text: '✅', key: message.key } });
+    } else {
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nDeepSeek is currently unavailable. Try again later.` 
+        }, { quoted: fake });
+    }
+}
+
+// ==================== LLAMA (WORKING) ====================
+async function llamaCommand(sock, chatId, message, args) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    const query = args.join(' ').trim();
+
+    if (!query) {
+        return sock.sendMessage(chatId, { 
+            text: `*${botName} LLAMA*\n\nUsage: .llama <question>\nExample: .llama write a python hello world` 
+        }, { quoted: fake });
+    }
+
+    await sock.sendMessage(chatId, { react: { text: '🦙', key: message.key } });
+
+    const result = await tryAPIs([
+        { url: `https://bk9.fun/ai/llama?q=${encodeURIComponent(query)}`, parse: d => d.BK9 || d.result },
+        { url: `https://api.dreaded.site/api/llama?text=${encodeURIComponent(query)}`, parse: d => d.response || d.result },
+        { url: `https://api.siputzx.my.id/api/ai/llama33-70b?content=${encodeURIComponent(query)}`, parse: d => d.data },
+    ]);
+
+    if (result) {
+        await sock.sendMessage(chatId, { text: result }, { quoted: fake });
+        await sock.sendMessage(chatId, { react: { text: '✅', key: message.key } });
+    } else {
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nLlama is currently unavailable. Try again later.` 
+        }, { quoted: fake });
+    }
+}
+
+// ==================== MIXTRAL (WORKING) ====================
+async function mixtralCommand(sock, chatId, message, args) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    const query = args.join(' ').trim();
+
+    if (!query) {
+        return sock.sendMessage(chatId, { 
+            text: `*${botName} MIXTRAL*\n\nUsage: .mixtral <question>\nExample: .mixtral explain APIs` 
+        }, { quoted: fake });
+    }
+
+    await sock.sendMessage(chatId, { react: { text: '🔮', key: message.key } });
+
+    const result = await tryAPIs([
+        { url: `https://bk9.fun/ai/mixtral?q=${encodeURIComponent(query)}`, parse: d => d.BK9 || d.result },
+        { url: `https://api.siputzx.my.id/api/ai/mixtral-8x7b?content=${encodeURIComponent(query)}`, parse: d => d.data },
+    ]);
+
+    if (result) {
+        await sock.sendMessage(chatId, { text: result }, { quoted: fake });
+        await sock.sendMessage(chatId, { react: { text: '✅', key: message.key } });
+    } else {
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nMixtral is currently unavailable. Try again later.` 
+        }, { quoted: fake });
+    }
+}
+
+// ==================== QWEN (WORKING) ====================
+async function qwenCommand(sock, chatId, message, args) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    const query = args.join(' ').trim();
+
+    if (!query) {
+        return sock.sendMessage(chatId, { 
+            text: `*${botName} QWEN*\n\nUsage: .qwen <question>\nExample: .qwen what is machine learning` 
+        }, { quoted: fake });
+    }
+
+    await sock.sendMessage(chatId, { react: { text: '🐉', key: message.key } });
+
+    const result = await tryAPIs([
+        { url: `https://bk9.fun/ai/qwen?q=${encodeURIComponent(query)}`, parse: d => d.BK9 || d.result },
+        { url: `https://api.siputzx.my.id/api/ai/qwen2.5-32b?content=${encodeURIComponent(query)}`, parse: d => d.data },
+    ]);
+
+    if (result) {
+        await sock.sendMessage(chatId, { text: result }, { quoted: fake });
+        await sock.sendMessage(chatId, { react: { text: '✅', key: message.key } });
+    } else {
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nQwen is currently unavailable. Try again later.` 
+        }, { quoted: fake });
+    }
+}
+
+// ==================== CLAUDE (WORKING) ====================
+async function claudeCommand(sock, chatId, message, args) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    const query = args.join(' ').trim();
+
+    if (!query) {
+        return sock.sendMessage(chatId, { 
+            text: `*${botName} CLAUDE*\n\nUsage: .claude <question>\nExample: .claude explain recursion` 
+        }, { quoted: fake });
+    }
+
+    await sock.sendMessage(chatId, { react: { text: '🤖', key: message.key } });
+
+    const result = await tryAPIs([
+        { url: `https://bk9.fun/ai/claude?q=${encodeURIComponent(query)}`, parse: d => d.BK9 || d.result },
+        { url: `https://api.dreaded.site/api/claude?text=${encodeURIComponent(query)}`, parse: d => d.response || d.result },
+    ]);
+
+    if (result) {
+        await sock.sendMessage(chatId, { text: result }, { quoted: fake });
+        await sock.sendMessage(chatId, { react: { text: '✅', key: message.key } });
+    } else {
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nClaude is currently unavailable. Try again later.` 
+        }, { quoted: fake });
+    }
+}
+
+// ==================== GPT-4O (WORKING) ====================
+async function gpt4oCommand(sock, chatId, message, args) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    const query = args.join(' ').trim();
+
+    if (!query) {
+        return sock.sendMessage(chatId, { 
+            text: `*${botName} GPT-4O*\n\nUsage: .gpt4o <question>\nExample: .gpt4o explain blockchain` 
+        }, { quoted: fake });
+    }
+
+    await sock.sendMessage(chatId, { react: { text: '⚡', key: message.key } });
+
+    const result = await tryAPIs([
+        { url: `https://bk9.fun/ai/GPT4o?q=${encodeURIComponent(query)}`, parse: d => d.BK9 || d.result },
+        { url: `https://api.dreaded.site/api/chatgpt?text=${encodeURIComponent(query)}`, parse: d => d.response || d.result },
+        { url: `https://api.siputzx.my.id/api/ai/gpt-4o?content=${encodeURIComponent(query)}`, parse: d => d.data },
+    ]);
+
+    if (result) {
+        await sock.sendMessage(chatId, { text: result }, { quoted: fake });
+        await sock.sendMessage(chatId, { react: { text: '✅', key: message.key } });
+    } else {
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nGPT-4o is currently unavailable. Try again later.` 
+        }, { quoted: fake });
+    }
+}
+
+// ==================== MISTRAL (WORKING) ====================
+async function mistralCommand(sock, chatId, message, args) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    const query = args.join(' ').trim();
+
+    if (!query) {
+        return sock.sendMessage(chatId, { 
+            text: `*${botName} MISTRAL*\n\nUsage: .mistral <question>\nExample: .mistral explain docker containers` 
+        }, { quoted: fake });
+    }
+
+    await sock.sendMessage(chatId, { react: { text: '🌬️', key: message.key } });
+
+    const result = await tryAPIs([
+        { url: `https://bk9.fun/ai/mistral?q=${encodeURIComponent(query)}`, parse: d => d.BK9 || d.result },
+        { url: `https://api.siputzx.my.id/api/ai/mistral-nemo?content=${encodeURIComponent(query)}`, parse: d => d.data },
+    ]);
+
+    if (result) {
+        await sock.sendMessage(chatId, { text: result }, { quoted: fake });
+        await sock.sendMessage(chatId, { react: { text: '✅', key: message.key } });
+    } else {
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nMistral is currently unavailable. Try again later.` 
+        }, { quoted: fake });
+    }
+}
+
+// ==================== GEMMA (WORKING) ====================
+async function gemmaCommand(sock, chatId, message, args) {
+    const fake = createFakeContact(message);
+    const botName = getBotName();
+    const query = args.join(' ').trim();
+
+    if (!query) {
+        return sock.sendMessage(chatId, { 
+            text: `*${botName} GEMMA*\n\nUsage: .gemma <question>\nExample: .gemma explain REST APIs` 
+        }, { quoted: fake });
+    }
+
+    await sock.sendMessage(chatId, { react: { text: '💎', key: message.key } });
+
+    const result = await tryAPIs([
+        { url: `https://bk9.fun/ai/gemma?q=${encodeURIComponent(query)}`, parse: d => d.BK9 || d.result },
+        { url: `https://api.siputzx.my.id/api/ai/gemma2-9b?content=${encodeURIComponent(query)}`, parse: d => d.data },
+    ]);
+
+    if (result) {
+        await sock.sendMessage(chatId, { text: result }, { quoted: fake });
+        await sock.sendMessage(chatId, { react: { text: '✅', key: message.key } });
+    } else {
+        await sock.sendMessage(chatId, { 
+            text: `*${botName}*\nGemma is currently unavailable. Try again later.` 
+        }, { quoted: fake });
+    }
+}
+
+// ==================== EXPORTS (EXACTLY AS BEFORE) ====================
+module.exports = {
+    deepseekCommand,
+    llamaCommand,
+    mixtralCommand,
+    qwenCommand,
+    claudeCommand,
+    gpt4oCommand,
+    mistralCommand,
+    gemmaCommand
+};

package/davexcore/ai/aivideo.js

@@ -0,0 +1,31 @@
+const { createFakeContact, getBotName } = require('../../davelib/fakeContact');
+const axios = require('axios');
+
+async function aivideoCommand(sock, chatId, message, args) {
+    const fakeContact = createFakeContact(message);
+    const botName = getBotName();
+    const prompt = args.join(' ').trim();
+    
+    if (!prompt) {
+        return sock.sendMessage(chatId, { text: `*${botName} AI VIDEO*\n\nUsage: .aivideo <prompt>\nExample: .aivideo a sunset over the ocean` }, { quoted: fakeContact });
+    }
+    
+    await sock.sendMessage(chatId, { react: { text: '🎬', key: message.key } });
+    await sock.sendMessage(chatId, { text: `*${botName}*\nGenerating video from: "${prompt}"\nThis may take a moment...` }, { quoted: fakeContact });
+    
+    try {
+        const res = await axios.get(`https://bk9.fun/ai/Kling?prompt=${encodeURIComponent(prompt)}`, { timeout: 60000 });
+        const videoUrl = res.data?.BK9 || res.data?.result || res.data?.url;
+        
+        if (videoUrl) {
+            await sock.sendMessage(chatId, { video: { url: videoUrl }, caption: `*${botName} AI VIDEO*\nPrompt: ${prompt}` }, { quoted: fakeContact });
+            await sock.sendMessage(chatId, { react: { text: '✅', key: message.key } });
+        } else {
+            await sock.sendMessage(chatId, { text: `*${botName}*\nFailed to generate video. Try a different prompt.` }, { quoted: fakeContact });
+        }
+    } catch (err) {
+        await sock.sendMessage(chatId, { text: `*${botName}*\nVideo generation failed: ${err.message}` }, { quoted: fakeContact });
+    }
+}
+
+module.exports = aivideoCommand;