opencode-pollinations-plugin 6.0.0-beta.18 → 6.0.0-beta.2

package/dist/tools/index.js

@@ -0,0 +1,75 @@
+/**
+ * Tool Registry — Conditional Injection System
+ *
+ * Free Universe (no key): 7 tools always available
+ * Enter Universe (with key): +5 Pollinations tools
+ *
+ * Tools are injected ONCE at plugin init. Restart needed after /poll connect.
+ */
+import { loadConfig } from '../server/config.js';
+// === FREE TOOLS (Always available) ===
+import { genQrcodeTool } from './design/gen_qrcode.js';
+import { genDiagramTool } from './design/gen_diagram.js';
+import { genPaletteTool } from './design/gen_palette.js';
+import { fileToUrlTool } from './power/file_to_url.js';
+import { removeBackgroundTool } from './power/remove_background.js';
+import { extractFramesTool } from './power/extract_frames.js';
+// === ENTER TOOLS (Require API key) ===
+// Phase 4D: Pollinations tools — TO BE IMPLEMENTED
+// import { genImageTool } from './pollinations/gen_image.js';
+// import { genVideoTool } from './pollinations/gen_video.js';
+// import { genAudioTool } from './pollinations/gen_audio.js';
+// import { genMusicTool } from './pollinations/gen_music.js';
+// import { deepsearchTool } from './pollinations/deepsearch.js';
+// import { searchCrawlScrapeTool } from './pollinations/search_crawl_scrape.js';
+import * as fs from 'fs';
+const LOG_FILE = '/tmp/opencode_pollinations_v4.log';
+function log(msg) {
+    try {
+        fs.appendFileSync(LOG_FILE, `[${new Date().toISOString()}] [Tools] ${msg}\n`);
+    }
+    catch { }
+}
+/**
+ * Detect if a valid API key is present
+ */
+function hasValidKey() {
+    const config = loadConfig();
+    return !!(config.apiKey && config.apiKey.length > 5 && config.apiKey !== 'dummy');
+}
+/**
+ * Build the tool registry based on user's access level
+ *
+ * @returns Record<string, Tool> to be spread into the plugin's tool: {} property
+ */
+export function createToolRegistry() {
+    const tools = {};
+    const keyPresent = hasValidKey();
+    const config = loadConfig();
+    // === FREE UNIVERSE: Always injected ===
+    // Design tools
+    tools['gen_qrcode'] = genQrcodeTool;
+    tools['gen_diagram'] = genDiagramTool;
+    tools['gen_palette'] = genPaletteTool;
+    // Power tools
+    tools['file_to_url'] = fileToUrlTool;
+    tools['remove_background'] = removeBackgroundTool;
+    tools['extract_frames'] = extractFramesTool;
+    // gen_image (free version) — TODO Phase 4D
+    // tools['gen_image'] = genImageTool;
+    log(`Free tools injected: ${Object.keys(tools).length}`);
+    // === ENTER UNIVERSE: Only with valid API key ===
+    if (keyPresent) {
+        // Pollinations paid tools — TODO Phase 4D
+        // tools['gen_video'] = genVideoTool;
+        // tools['gen_audio'] = genAudioTool;
+        // tools['gen_music'] = genMusicTool;
+        // tools['deepsearch'] = deepsearchTool;
+        // tools['search_crawl_scrape'] = searchCrawlScrapeTool;
+        log(`Enter tools injected (key detected). Total: ${Object.keys(tools).length}`);
+    }
+    else {
+        log(`Enter tools SKIPPED (no key). Total: ${Object.keys(tools).length}`);
+    }
+    return tools;
+}

package/dist/tools/power/extract_frames.d.ts

@@ -0,0 +1,2 @@
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const extractFramesTool: ToolDefinition;

package/dist/tools/power/extract_frames.js

@@ -0,0 +1,215 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import * as https from 'https';
+import * as http from 'http';
+const SAVE_DIR = path.join(os.homedir(), 'Downloads', 'pollinations', 'frames');
+/**
+ * Download a video from URL to a temp file
+ */
+function downloadVideo(url) {
+    return new Promise((resolve, reject) => {
+        const tempPath = path.join(os.tmpdir(), `video_${Date.now()}.mp4`);
+        const proto = url.startsWith('https') ? https : http;
+        const req = proto.get(url, { headers: { 'User-Agent': 'OpenCode-Pollinations-Plugin/6.0' } }, (res) => {
+            // Follow redirects
+            if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                return downloadVideo(res.headers.location).then(resolve).catch(reject);
+            }
+            if (res.statusCode && res.statusCode >= 400) {
+                return reject(new Error(`HTTP ${res.statusCode}`));
+            }
+            const ws = fs.createWriteStream(tempPath);
+            res.pipe(ws);
+            ws.on('finish', () => {
+                ws.close();
+                resolve(tempPath);
+            });
+            ws.on('error', reject);
+        });
+        req.on('error', reject);
+        req.setTimeout(120000, () => {
+            req.destroy();
+            reject(new Error('Download timeout (120s)'));
+        });
+    });
+}
+/**
+ * Try to load @ffmpeg/ffmpeg dynamically — it's an optional peer dependency
+ */
+async function loadFFmpeg() {
+    try {
+        // @ts-ignore — optional peer dependency
+        const { FFmpeg } = await import('@ffmpeg/ffmpeg');
+        // @ts-ignore — optional peer dependency
+        const { toBlobURL } = await import('@ffmpeg/util');
+        return { FFmpeg, toBlobURL };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if system ffmpeg is available (fallback)
+ */
+function hasSystemFFmpeg() {
+    try {
+        const { execSync } = require('child_process');
+        execSync('ffmpeg -version', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Extract frames using system ffmpeg
+ */
+function extractWithSystemFFmpeg(videoPath, outputDir, baseName, options) {
+    const { execSync } = require('child_process');
+    const outputPattern = path.join(outputDir, `${baseName}_%03d.png`);
+    const outputs = [];
+    let cmd = `ffmpeg -y -i "${videoPath}"`;
+    if (options.at_time) {
+        // Single frame at specific time
+        cmd += ` -ss ${options.at_time} -frames:v 1`;
+        const singleOutput = path.join(outputDir, `${baseName}_at_${options.at_time.replace(/:/g, '-')}.png`);
+        cmd += ` "${singleOutput}"`;
+        execSync(cmd, { stdio: 'ignore', timeout: 60000 });
+        if (fs.existsSync(singleOutput))
+            outputs.push(singleOutput);
+    }
+    else {
+        // Range extraction
+        if (options.start)
+            cmd += ` -ss ${options.start}`;
+        if (options.end)
+            cmd += ` -to ${options.end}`;
+        const fps = options.fps || 1; // Default 1 fps
+        cmd += ` -vf "fps=${fps}" "${outputPattern}"`;
+        execSync(cmd, { stdio: 'ignore', timeout: 120000 });
+        // Collect generated files
+        const files = fs.readdirSync(outputDir);
+        files.filter(f => f.startsWith(baseName) && f.endsWith('.png'))
+            .sort()
+            .forEach(f => outputs.push(path.join(outputDir, f)));
+    }
+    return outputs;
+}
+function formatFileSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+export const extractFramesTool = tool({
+    description: `Extract image frames from a video file or URL.
+Can extract a single frame at a specific timestamp, or multiple frames from a time range.
+Requires either system ffmpeg installed or @ffmpeg/ffmpeg npm package.
+Supports MP4, WebM, and other common video formats.
+Free to use — no API key needed.`,
+    args: {
+        source: tool.schema.string().describe('Video file path (absolute) or URL'),
+        at_time: tool.schema.string().optional().describe('Extract single frame at timestamp (e.g. "00:00:05" or "5")'),
+        start: tool.schema.string().optional().describe('Start time for range extraction (e.g. "00:00:02")'),
+        end: tool.schema.string().optional().describe('End time for range extraction (e.g. "00:00:10")'),
+        fps: tool.schema.number().min(0.1).max(30).optional().describe('Frames per second for range extraction (default: 1)'),
+        filename: tool.schema.string().optional().describe('Base filename prefix. Auto-generated if omitted'),
+    },
+    async execute(args, context) {
+        // Check ffmpeg availability
+        const systemFFmpeg = hasSystemFFmpeg();
+        if (!systemFFmpeg) {
+            // Try wasm ffmpeg
+            const ffmpegWasm = await loadFFmpeg();
+            if (!ffmpegWasm) {
+                return [
+                    `❌ FFmpeg not found!`,
+                    ``,
+                    `This tool requires ffmpeg. Install one of:`,
+                    `  • System: sudo apt install ffmpeg  (or brew install ffmpeg)`,
+                    `  • Node.js: npm install @ffmpeg/ffmpeg @ffmpeg/util @ffmpeg/core`,
+                ].join('\n');
+            }
+            // TODO: Implement wasm extraction path (system ffmpeg is sufficient for MVP)
+            return `❌ @ffmpeg/ffmpeg wasm path not yet implemented. Please install system ffmpeg: sudo apt install ffmpeg`;
+        }
+        // Ensure save directory
+        if (!fs.existsSync(SAVE_DIR)) {
+            fs.mkdirSync(SAVE_DIR, { recursive: true });
+        }
+        // Resolve source: URL → download, path → validate
+        let videoPath;
+        let isRemote = false;
+        if (args.source.startsWith('http://') || args.source.startsWith('https://')) {
+            isRemote = true;
+            context.metadata({ title: `🎬 Downloading video...` });
+            try {
+                videoPath = await downloadVideo(args.source);
+            }
+            catch (err) {
+                return `❌ Download error: ${err.message}`;
+            }
+        }
+        else {
+            videoPath = args.source;
+            if (!fs.existsSync(videoPath)) {
+                return `❌ File not found: ${videoPath}`;
+            }
+        }
+        const baseName = args.filename
+            ? args.filename.replace(/[^a-zA-Z0-9_-]/g, '_')
+            : `frame_${Date.now()}`;
+        try {
+            context.metadata({ title: `🎬 Extracting frames...` });
+            const extractedFiles = extractWithSystemFFmpeg(videoPath, SAVE_DIR, baseName, {
+                at_time: args.at_time,
+                start: args.start,
+                end: args.end,
+                fps: args.fps,
+            });
+            // Cleanup temp video if downloaded
+            if (isRemote && fs.existsSync(videoPath)) {
+                try {
+                    fs.unlinkSync(videoPath);
+                }
+                catch { }
+            }
+            if (extractedFiles.length === 0) {
+                return `❌ No frames extracted. Check your timestamps and video source.`;
+            }
+            // Calculate total size
+            const totalSize = extractedFiles.reduce((sum, f) => sum + fs.statSync(f).size, 0);
+            const fileList = extractedFiles.length <= 5
+                ? extractedFiles.map(f => `  ${path.basename(f)}`).join('\n')
+                : [
+                    ...extractedFiles.slice(0, 3).map(f => `  ${path.basename(f)}`),
+                    `  ... and ${extractedFiles.length - 3} more`,
+                ].join('\n');
+            return [
+                `🎬 Frames Extracted`,
+                `━━━━━━━━━━━━━━━━━━━`,
+                `Source: ${isRemote ? args.source : path.basename(videoPath)}`,
+                `Frames: ${extractedFiles.length}`,
+                `Directory: ${SAVE_DIR}`,
+                `Total size: ${formatFileSize(totalSize)}`,
+                `Files:`,
+                fileList,
+                ``,
+                `Cost: Free (local ffmpeg)`,
+            ].join('\n');
+        }
+        catch (err) {
+            // Cleanup on error
+            if (isRemote && fs.existsSync(videoPath)) {
+                try {
+                    fs.unlinkSync(videoPath);
+                }
+                catch { }
+            }
+            return `❌ Frame extraction error: ${err.message}`;
+        }
+    },
+});

package/dist/tools/power/file_to_url.d.ts

@@ -0,0 +1,2 @@
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const fileToUrlTool: ToolDefinition;

package/dist/tools/power/file_to_url.js

@@ -0,0 +1,217 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import * as https from 'https';
+import * as http from 'http';
+import * as fs from 'fs';
+import * as path from 'path';
+const PROVIDERS = [
+    // Provider 1: Litterbox (catbox.moe) — fiable, anonyme, testé OK
+    {
+        name: 'litterbox.catbox.moe',
+        maxSize: 200 * 1024 * 1024, // 200MB
+        expiry: '1h-72h',
+        upload: (filePath, fileName, fileData, mimeType, expiry) => httpUpload({
+            url: 'https://litterbox.catbox.moe/resources/internals/api.php',
+            fields: { reqtype: 'fileupload', time: expiry },
+            fileField: 'fileToUpload',
+            fileName, fileData, mimeType,
+            parseResponse: (body) => {
+                const trimmed = body.trim();
+                if (trimmed.startsWith('https://'))
+                    return trimmed;
+                throw new Error(`Réponse inattendue: ${trimmed.substring(0, 100)}`);
+            },
+        }),
+    },
+    // Provider 2: tmpfile.link — CDN rapide, 100MB max, 7j
+    {
+        name: 'tmpfile.link',
+        maxSize: 100 * 1024 * 1024, // 100MB
+        expiry: '7 jours',
+        upload: (filePath, fileName, fileData, mimeType) => httpUpload({
+            url: 'https://tmpfile.link/api/upload',
+            fields: {},
+            fileField: 'file',
+            fileName, fileData, mimeType,
+            parseResponse: (body) => {
+                const json = JSON.parse(body);
+                if (json.downloadLink)
+                    return json.downloadLink;
+                throw new Error(`Pas de downloadLink: ${body.substring(0, 100)}`);
+            },
+        }),
+    },
+    // Provider 3: file.io — auto-destruction après 1er téléchargement
+    {
+        name: 'file.io',
+        maxSize: 2 * 1024 * 1024 * 1024, // 2GB
+        expiry: '14 jours (auto-détruit)',
+        upload: (filePath, fileName, fileData, mimeType) => httpUpload({
+            url: 'https://file.io',
+            fields: { expires: '14d' },
+            fileField: 'file',
+            fileName, fileData, mimeType,
+            parseResponse: (body) => {
+                const json = JSON.parse(body);
+                if (json.success && json.link)
+                    return json.link;
+                throw new Error(`file.io erreur: ${json.message || body.substring(0, 100)}`);
+            },
+        }),
+    },
+];
+function httpUpload(opts) {
+    return new Promise((resolve, reject) => {
+        const boundary = `----FormBoundary${Date.now()}${Math.random().toString(36).slice(2)}`;
+        const parts = [];
+        // Text fields
+        for (const [key, value] of Object.entries(opts.fields)) {
+            parts.push(Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="${key}"\r\n\r\n${value}\r\n`));
+        }
+        // File field
+        parts.push(Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="${opts.fileField}"; filename="${opts.fileName}"\r\nContent-Type: ${opts.mimeType}\r\n\r\n`));
+        parts.push(opts.fileData);
+        parts.push(Buffer.from(`\r\n--${boundary}--\r\n`));
+        const body = Buffer.concat(parts);
+        const url = new URL(opts.url);
+        const isHttps = url.protocol === 'https:';
+        const mod = isHttps ? https : http;
+        const req = mod.request({
+            hostname: url.hostname,
+            path: url.pathname,
+            method: 'POST',
+            headers: {
+                'Content-Type': `multipart/form-data; boundary=${boundary}`,
+                'Content-Length': body.length,
+                'User-Agent': 'Mozilla/5.0 (compatible; OpenCode-Plugin/6.0)',
+                'Accept': 'application/json, text/plain, */*',
+            },
+        }, (res) => {
+            // Follow redirects (301, 302, 307)
+            if (res.statusCode && [301, 302, 307].includes(res.statusCode) && res.headers.location) {
+                httpUpload({ ...opts, url: res.headers.location }).then(resolve).catch(reject);
+                return;
+            }
+            let data = '';
+            res.on('data', (chunk) => data += chunk);
+            res.on('end', () => {
+                if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                    try {
+                        resolve(opts.parseResponse(data));
+                    }
+                    catch (err) {
+                        reject(new Error(`Parse error: ${err.message}`));
+                    }
+                }
+                else {
+                    reject(new Error(`HTTP ${res.statusCode}: ${data.substring(0, 200)}`));
+                }
+            });
+        });
+        req.on('error', (err) => reject(new Error(`Réseau: ${err.message}`)));
+        req.setTimeout(45000, () => {
+            req.destroy();
+            reject(new Error('Timeout (45s)'));
+        });
+        req.write(body);
+        req.end();
+    });
+}
+// ─── Upload with Cascade Fallback ───────────────────────────────────────────
+async function uploadWithFallback(filePath, fileSize, expiry) {
+    const fileName = path.basename(filePath);
+    const fileData = fs.readFileSync(filePath);
+    const mimeType = getMimeType(fileName);
+    const attempts = [];
+    for (const provider of PROVIDERS) {
+        if (fileSize > provider.maxSize) {
+            attempts.push(`⏭️ ${provider.name}: fichier trop gros (max ${formatFileSize(provider.maxSize)})`);
+            continue;
+        }
+        try {
+            const url = await provider.upload(filePath, fileName, fileData, mimeType, expiry);
+            return { url, provider: provider.name, expiry: provider.expiry, attempts };
+        }
+        catch (err) {
+            attempts.push(`❌ ${provider.name}: ${err.message}`);
+        }
+    }
+    throw new Error(`Tous les services d'upload ont échoué:\n${attempts.join('\n')}`);
+}
+// ─── Utils ──────────────────────────────────────────────────────────────────
+function getMimeType(filename) {
+    const ext = path.extname(filename).toLowerCase();
+    const types = {
+        '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif', '.webp': 'image/webp', '.svg': 'image/svg+xml',
+        '.mp4': 'video/mp4', '.webm': 'video/webm', '.mp3': 'audio/mpeg',
+        '.wav': 'audio/wav', '.ogg': 'audio/ogg', '.flac': 'audio/flac',
+        '.pdf': 'application/pdf', '.txt': 'text/plain',
+        '.json': 'application/json', '.html': 'text/html', '.css': 'text/css',
+        '.js': 'application/javascript', '.ts': 'text/typescript',
+        '.zip': 'application/zip', '.tar': 'application/x-tar',
+        '.gz': 'application/gzip', '.7z': 'application/x-7z-compressed',
+    };
+    return types[ext] || 'application/octet-stream';
+}
+function formatFileSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+// ─── Tool Definition ────────────────────────────────────────────────────────
+export const fileToUrlTool = tool({
+    description: `Upload a local file to get a temporary public URL.
+Uses a resilient multi-provider system with automatic fallback:
+  1. litterbox.catbox.moe (200MB, 1h-72h, anonymous)
+  2. tmpfile.link (100MB, 7 days, CDN global)
+  3. file.io (2GB, auto-destruct after 1 download)
+If one service is down, the next one is tried automatically.
+No API key needed, no account required.`,
+    args: {
+        file_path: tool.schema.string().describe('Absolute path to the local file to upload'),
+        expiry: tool.schema.enum(['1h', '12h', '24h', '72h']).optional()
+            .describe('How long the URL stays active on primary provider (default: 24h)'),
+    },
+    async execute(args, context) {
+        const expiry = args.expiry || '24h';
+        // Validate file exists
+        if (!fs.existsSync(args.file_path)) {
+            return `❌ Fichier introuvable: ${args.file_path}`;
+        }
+        const stats = fs.statSync(args.file_path);
+        if (stats.size === 0) {
+            return `❌ Fichier vide: ${args.file_path}`;
+        }
+        if (stats.size > 2 * 1024 * 1024 * 1024) {
+            return `❌ Fichier trop volumineux (${formatFileSize(stats.size)}). Max: 2 GB`;
+        }
+        try {
+            context.metadata({ title: `📤 Upload: ${path.basename(args.file_path)}` });
+            const result = await uploadWithFallback(args.file_path, stats.size, expiry);
+            const lines = [
+                `📤 Fichier Uploadé`,
+                `━━━━━━━━━━━━━━━━━━`,
+                `Fichier: ${path.basename(args.file_path)}`,
+                `Taille: ${formatFileSize(stats.size)}`,
+                `URL: ${result.url}`,
+                `Service: ${result.provider}`,
+                `Expiration: ${result.expiry}`,
+                ``,
+                `Coût: Gratuit (hébergement anonyme)`,
+            ];
+            // Show fallback attempts if any
+            if (result.attempts.length > 0) {
+                lines.push('', '⚠️ Fallbacks utilisés:');
+                lines.push(...result.attempts);
+            }
+            return lines.join('\n');
+        }
+        catch (err) {
+            return `❌ Erreur Upload: ${err.message}`;
+        }
+    },
+});

package/dist/tools/power/remove_background.d.ts

@@ -0,0 +1,2 @@
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const removeBackgroundTool: ToolDefinition;

package/dist/tools/power/remove_background.js

@@ -0,0 +1,115 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import * as https from 'https';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+const SAVE_DIR = path.join(os.homedir(), 'Downloads', 'pollinations', 'rembg');
+const REMBG_API_URL = 'https://cut.esprit-artificiel.com';
+const REMBG_API_KEY = 'sk-cut-fkomEA2026-hybridsoap161200';
+/**
+ * Send image to rembg API for background removal
+ */
+function removeBackground(imagePath) {
+    return new Promise((resolve, reject) => {
+        const imageData = fs.readFileSync(imagePath);
+        const boundary = `----FormBoundary${Date.now()}`;
+        const parts = [];
+        const ext = path.extname(imagePath).toLowerCase();
+        const mimeType = ext === '.png' ? 'image/png' : ext === '.webp' ? 'image/webp' : 'image/jpeg';
+        parts.push(Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="${path.basename(imagePath)}"\r\nContent-Type: ${mimeType}\r\n\r\n`));
+        parts.push(imageData);
+        parts.push(Buffer.from(`\r\n--${boundary}--\r\n`));
+        const body = Buffer.concat(parts);
+        const url = new URL(`${REMBG_API_URL}/remove-bg`);
+        const req = https.request({
+            hostname: url.hostname,
+            path: url.pathname,
+            method: 'POST',
+            headers: {
+                'Content-Type': `multipart/form-data; boundary=${boundary}`,
+                'Content-Length': body.length,
+                'X-Api-Key': REMBG_API_KEY,
+                'User-Agent': 'OpenCode-Pollinations-Plugin/6.0',
+            },
+        }, (res) => {
+            if (res.statusCode && res.statusCode >= 400) {
+                let errData = '';
+                res.on('data', (chunk) => errData += chunk);
+                res.on('end', () => reject(new Error(`API Error ${res.statusCode}: ${errData.substring(0, 200)}`)));
+                return;
+            }
+            const chunks = [];
+            res.on('data', (chunk) => chunks.push(chunk));
+            res.on('end', () => resolve(Buffer.concat(chunks)));
+        });
+        req.on('error', reject);
+        req.setTimeout(60000, () => {
+            req.destroy();
+            reject(new Error('Background removal timeout (60s)'));
+        });
+        req.write(body);
+        req.end();
+    });
+}
+function formatFileSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+export const removeBackgroundTool = tool({
+    description: `Remove the background from an image, producing a transparent PNG.
+Uses AI-powered background removal (u2netp model).
+Supports PNG, JPEG, and WebP input formats.
+Free to use — no API key or pollen required.`,
+    args: {
+        image_path: tool.schema.string().describe('Absolute path to the image file'),
+        filename: tool.schema.string().optional().describe('Custom output filename (without extension). Auto-generated if omitted'),
+    },
+    async execute(args, context) {
+        // Validate input
+        if (!fs.existsSync(args.image_path)) {
+            return `❌ File not found: ${args.image_path}`;
+        }
+        const ext = path.extname(args.image_path).toLowerCase();
+        if (!['.png', '.jpg', '.jpeg', '.webp'].includes(ext)) {
+            return `❌ Unsupported format: ${ext}. Use PNG, JPEG, or WebP.`;
+        }
+        const inputStats = fs.statSync(args.image_path);
+        if (inputStats.size > 10 * 1024 * 1024) {
+            return `❌ File too large (${formatFileSize(inputStats.size)}). Max: 10MB`;
+        }
+        // Ensure save directory
+        if (!fs.existsSync(SAVE_DIR)) {
+            fs.mkdirSync(SAVE_DIR, { recursive: true });
+        }
+        const safeName = args.filename
+            ? args.filename.replace(/[^a-zA-Z0-9_-]/g, '_')
+            : `${path.basename(args.image_path, ext)}_nobg`;
+        const outputPath = path.join(SAVE_DIR, `${safeName}.png`);
+        try {
+            context.metadata({ title: `✂️ Removing background: ${path.basename(args.image_path)}` });
+            const resultBuffer = await removeBackground(args.image_path);
+            if (resultBuffer.length < 100) {
+                return `❌ Background removal returned invalid data. The API might be temporarily unavailable.`;
+            }
+            fs.writeFileSync(outputPath, resultBuffer);
+            return [
+                `✂️ Background Removed`,
+                `━━━━━━━━━━━━━━━━━━━━━`,
+                `Input: ${path.basename(args.image_path)} (${formatFileSize(inputStats.size)})`,
+                `Output: ${outputPath}`,
+                `Size: ${formatFileSize(resultBuffer.length)}`,
+                `Format: PNG (transparent)`,
+                `Cost: Free`,
+            ].join('\n');
+        }
+        catch (err) {
+            if (err.message.includes('429') || err.message.includes('rate')) {
+                return `⏳ Rate limited. The background removal service is busy. Please try again in 30 seconds.`;
+            }
+            return `❌ Background Removal Error: ${err.message}`;
+        }
+    },
+});

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "opencode-pollinations-plugin",
-    "displayName": "Pollinations AI (V5.6)",
-    "version": "6.0.0-beta.18",
+    "displayName": "Pollinations AI (V5.9)",
+    "version": "6.0.0-beta.2",
     "description": "Native Pollinations.ai Provider Plugin for OpenCode",
     "publisher": "pollinations",
     "repository": {
@@ -49,10 +49,12 @@
     ],
     "dependencies": {
         "@opencode-ai/plugin": "^1.0.85",
-        "zod": "^3.22.4"
+        "qrcode": "^1.5.4",
+        "zod": "^3.25.76"
     },
     "devDependencies": {
         "@types/node": "^20.0.0",
+        "@types/qrcode": "^1.5.6",
         "typescript": "^5.0.0"
     }
-}
+}

package/dist/server/models-seed.d.ts

@@ -1,18 +0,0 @@
-export interface PollinationsModel {
-    name: string;
-    description?: string;
-    type?: string;
-    tools?: boolean;
-    reasoning?: boolean;
-    context?: number;
-    context_window?: number;
-    input_modalities?: string[];
-    output_modalities?: string[];
-    paid_only?: boolean;
-    vision?: boolean;
-    audio?: boolean;
-    community?: boolean;
-    censored?: boolean;
-    [key: string]: any;
-}
-export declare const FREE_MODELS_SEED: PollinationsModel[];