opencode-pollinations-plugin 6.0.0 → 6.1.0-beta.10

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,365 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import { emitStatusToast } from '../../server/toast.js';
+import * as https from 'https';
+import * as fs from 'fs';
+import * as path from 'path';
+import { resolveOutputDir, formatFileSize, TOOL_DIRS } from '../shared.js';
+// ─── Provider Defaults ───────────────────────────────────────────────────────
+const CUT_API_URL = 'https://cut.esprit-artificiel.com';
+const CUT_API_KEY = 'sk-cut-fkomEA2026-hybridsoap161200';
+const BACKGROUNDCUT_API_URL = 'https://backgroundcut.co/api/v1/cut/';
+// ─── Key Storage ─────────────────────────────────────────────────────────────
+const KEYS_FILE = path.join(process.env.HOME || process.env.USERPROFILE || '/tmp', '.pollinations', 'backgroundcut_keys.json');
+function loadKeys() {
+    try {
+        if (fs.existsSync(KEYS_FILE)) {
+            return JSON.parse(fs.readFileSync(KEYS_FILE, 'utf-8'));
+        }
+    }
+    catch { }
+    return { keys: [], currentIndex: 0 };
+}
+function getRotatedKeys() {
+    const store = loadKeys();
+    if (store.keys.length === 0)
+        return [];
+    // Return keys starting from currentIndex looping back to start
+    const before = store.keys.slice(store.currentIndex);
+    const after = store.keys.slice(0, store.currentIndex);
+    return [...before, ...after];
+}
+function advanceKeyIndex() {
+    const store = loadKeys();
+    if (store.keys.length === 0)
+        return;
+    store.currentIndex = (store.currentIndex + 1) % store.keys.length;
+    try {
+        const dir = path.dirname(KEYS_FILE);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(KEYS_FILE, JSON.stringify(store, null, 2));
+    }
+    catch { }
+}
+// ─── HTTP Helpers ────────────────────────────────────────────────────────────
+function httpRequest(url, options, body) {
+    return new Promise((resolve, reject) => {
+        const req = https.request(url, options, (res) => {
+            const chunks = [];
+            res.on('data', (chunk) => chunks.push(chunk));
+            res.on('end', () => {
+                const responseBody = Buffer.concat(chunks);
+                const statusCode = res.statusCode || 500;
+                let json;
+                try {
+                    json = JSON.parse(responseBody.toString());
+                }
+                catch { }
+                resolve({ statusCode, body: responseBody, json });
+            });
+        });
+        req.on('error', reject);
+        req.setTimeout(60000, () => { req.destroy(); reject(new Error('Request timeout (60s)')); });
+        if (body)
+            req.write(body);
+        req.end();
+    });
+}
+function downloadFile(url) {
+    return new Promise((resolve, reject) => {
+        const protocol = url.startsWith('https') ? https : require('http');
+        protocol.get(url, (res) => {
+            // Handle redirects
+            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                return downloadFile(res.headers.location).then(resolve).catch(reject);
+            }
+            const chunks = [];
+            res.on('data', (c) => chunks.push(c));
+            res.on('end', () => resolve(Buffer.concat(chunks)));
+        }).on('error', reject);
+    });
+}
+// ─── Helper: Get Image Size (Linux/Unix 'file' command) ─────────────────────
+function getImageSize(filePath) {
+    try {
+        const { execSync } = require('child_process');
+        const output = execSync(`file "${filePath}"`).toString();
+        // Regex for "IDAT, 800 x 600," or ", 800 x 600,"
+        const match = output.match(/, (\d+) ?x ?(\d+),/);
+        if (match) {
+            return { width: parseInt(match[1], 10), height: parseInt(match[2], 10) };
+        }
+    }
+    catch (e) {
+        // Fallback or silence
+    }
+    return null;
+}
+// ─── Provider: cut.esprit-artificiel.com (returns binary PNG directly) ────────
+async function removeViaCut(imageData, filename, mimeType) {
+    const boundary = `----FormBoundary${Date.now()}`;
+    const parts = [];
+    parts.push(Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="${filename}"\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(`${CUT_API_URL}/remove-bg`);
+    const res = await httpRequest(url.toString(), {
+        method: 'POST',
+        headers: {
+            'Content-Type': `multipart/form-data; boundary=${boundary}`,
+            'Content-Length': body.length,
+            'X-Api-Key': CUT_API_KEY,
+            'User-Agent': 'OpenCode-Pollinations-Plugin/6.0',
+        },
+    }, body);
+    if (res.statusCode >= 400) {
+        throw new Error(`CUT API Error ${res.statusCode}: ${res.body.toString().substring(0, 200)}`);
+    }
+    return res.body;
+}
+// ─── Provider: BackgroundCut.co (returns JSON with output_image_url) ─────────
+async function removeViaBackgroundCut(imageData, filename, mimeType, apiKey, quality = 'medium', returnFormat = 'png', maxResolution) {
+    const boundary = `----FormBoundary${Date.now()}`;
+    const parts = [];
+    // File field
+    parts.push(Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="file"; filename="${filename}"\r\nContent-Type: ${mimeType}\r\n\r\n`));
+    parts.push(imageData);
+    // Quality
+    parts.push(Buffer.from(`\r\n--${boundary}\r\nContent-Disposition: form-data; name="quality"\r\n\r\n${quality}`));
+    // Return format
+    parts.push(Buffer.from(`\r\n--${boundary}\r\nContent-Disposition: form-data; name="return_format"\r\n\r\n${returnFormat.toUpperCase()}`));
+    // Max resolution
+    if (maxResolution) {
+        parts.push(Buffer.from(`\r\n--${boundary}\r\nContent-Disposition: form-data; name="max_resolution"\r\n\r\n${maxResolution}`));
+    }
+    parts.push(Buffer.from(`\r\n--${boundary}--\r\n`));
+    const body = Buffer.concat(parts);
+    const res = await httpRequest(BACKGROUNDCUT_API_URL, {
+        method: 'POST',
+        headers: {
+            'Content-Type': `multipart/form-data; boundary=${boundary}`,
+            'Content-Length': body.length,
+            'Authorization': `Token ${apiKey}`,
+            'User-Agent': 'OpenCode-Pollinations-Plugin/6.0',
+        },
+    }, body);
+    // Error handling with specific codes
+    if (res.statusCode === 401)
+        throw new Error('BGCUT_401:Invalid or missing API key');
+    if (res.statusCode === 402)
+        throw new Error('BGCUT_402:No credits remaining');
+    if (res.statusCode === 429)
+        throw new Error('BGCUT_429:Rate limit exceeded');
+    if (res.statusCode === 413)
+        throw new Error('BGCUT_413:File too large (max 12MB)');
+    if (res.statusCode >= 400) {
+        const msg = res.json?.error || res.body.toString().substring(0, 200);
+        throw new Error(`BGCUT_${res.statusCode}:${msg}`);
+    }
+    // Download the result image from the URL
+    const outputUrl = res.json?.output_image_url;
+    if (!outputUrl)
+        throw new Error('BackgroundCut returned no output URL');
+    return await downloadFile(outputUrl);
+}
+// ─── Main Tool ───────────────────────────────────────────────────────────────
+export const removeBackgroundTool = tool({
+    description: `Remove the background from an image, producing a transparent PNG or WebP.
+
+**Providers:**
+- \`cut\` (default free) — Built-in u2netp AI. Slower. Ignores quality/format/resolution.
+- \`backgroundcut\` — Premium API. Requires API key. Supports all parameters.
+
+**Setup:** Use \`rmbg_keys\` tool to manage API keys.
+**Auto mode:** Uses BackgroundCut if key is available, falls back to cut.`,
+    args: {
+        image_path: tool.schema.string().describe('Absolute path to the image file'),
+        filename: tool.schema.string().optional().describe('Custom output filename (e.g. "my_image.png") or name without extension'),
+        output_path: tool.schema.string().optional().describe('Custom output directory. Default: ~/Downloads/pollinations/rembg/'),
+        provider: tool.schema.string().optional().describe('Provider: "auto" (default), "cut" (free), or "backgroundcut" (premium)'), // Removed .enum() as it caused errors
+        api_key: tool.schema.string().optional().describe('BackgroundCut API key (overrides stored keys)'),
+        quality: tool.schema.string().optional().describe('BackgroundCut only: "low", "medium" (default), "high"'),
+        return_format: tool.schema.string().optional().describe('BackgroundCut only: "png" (default), "webp"'),
+        max_resolution: tool.schema.number().optional().describe('BackgroundCut only: Max output resolution in pixels'),
+    },
+    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 > 12 * 1024 * 1024) {
+            return `❌ File too large (${formatFileSize(inputStats.size)}). Max: 12MB`;
+        }
+        // ── Resolve provider ──
+        const provider = (args.provider || 'auto');
+        const quality = (args.quality || 'medium');
+        const returnFormat = (args.return_format || 'png');
+        const imageData = fs.readFileSync(args.image_path);
+        const mimeType = ext === '.png' ? 'image/png' : ext === '.webp' ? 'image/webp' : 'image/jpeg';
+        const basename = path.basename(args.image_path);
+        // ─── Resolve API keys ──
+        let keysToCheck = [];
+        if (args.api_key) {
+            keysToCheck = [args.api_key];
+        }
+        else {
+            keysToCheck = getRotatedKeys();
+        }
+        // ── Determine initial provider strategy ──
+        // If specific provider requested, we stick to it (unless auto fallback)
+        // If auto, we try keys then fallback to cut
+        let effectiveProvider = provider;
+        if (provider === 'auto') {
+            // If we have keys, start with backgroundcut, else cut
+            effectiveProvider = keysToCheck.length > 0 ? 'backgroundcut' : 'cut';
+        }
+        // ── Info message when no BackgroundCut key ──
+        if (keysToCheck.length === 0 && (provider === 'auto' || provider === 'backgroundcut')) {
+            // console.log("No BackgroundCut key found. Using free provider."); // SILENCED
+            context.metadata({
+                title: "RMBG (Free)",
+                metadata: { type: 'info', message: "Mode Gratuit (Pas de clé détectée)" }
+            });
+            const noKeyMsg = [
+                `ℹ️ **No BackgroundCut API key configured** — using free provider (slower, rate-limited).`,
+                ``,
+                `🚀 **Want faster, higher-quality results?**`,
+                `1. Sign up at https://backgroundcut.co (5$ free credits, 60 days)`,
+                `2. Run: \`rmbg_keys action=add key=YOUR_API_KEY\``,
+                `3. Multiple keys supported — they rotate automatically!`,
+            ].join('\n');
+            if (provider === 'backgroundcut' && !args.api_key) {
+                return `❌ BackgroundCut provider selected but no API keys stored.\n\n${noKeyMsg}`;
+            }
+            // In auto mode, we continue with free provider
+            context.metadata({ title: `ℹ️ Using free provider (no BackgroundCut key)` });
+        }
+        // ── Resolve output filename ──
+        const outputDir = resolveOutputDir(TOOL_DIRS.rembg, args.output_path);
+        let finalFilename = '';
+        const targetExt = (returnFormat === 'webp' && effectiveProvider === 'backgroundcut') ? '.webp' : '.png';
+        if (args.filename) {
+            if (args.filename.toLowerCase().endsWith(targetExt)) {
+                finalFilename = args.filename;
+            }
+            else if (args.filename.match(/\.[a-z0-9]+$/i)) {
+                // Force proper extension
+                finalFilename = args.filename.replace(/\.[a-z0-9]+$/i, targetExt);
+            }
+            else {
+                finalFilename = `${args.filename}${targetExt}`;
+            }
+        }
+        else {
+            finalFilename = `${path.basename(args.image_path, ext)}_nobg${targetExt}`;
+        }
+        const outputPath = path.join(outputDir, finalFilename);
+        const outputExt = path.extname(outputPath).replace('.', ''); // Fix for log display
+        // ── Execute ──
+        try {
+            let resultBuffer = null;
+            let usedProvider = 'cut'; // Default
+            let fallbackUsed = false;
+            let successKey = '';
+            // 1. Try BackgroundCut loop if applicable
+            if (effectiveProvider === 'backgroundcut' && keysToCheck.length > 0) {
+                emitStatusToast('info', `Démarrage: ${basename}`, '✂️ BackgroundCut');
+                for (const key of keysToCheck) {
+                    try {
+                        emitStatusToast('info', `Clé ${key.substring(0, 8)}...`, '>>> Rotation RMBG');
+                        // console.log(`[RMBG] Trying key ${key.substring(0, 8)}...`); // SILENCED
+                        resultBuffer = await removeViaBackgroundCut(imageData, basename, mimeType, key, quality, returnFormat, args.max_resolution);
+                        // Success!
+                        usedProvider = 'backgroundcut';
+                        successKey = key;
+                        // Advance index globally so next call uses next key (fair rotation)
+                        advanceKeyIndex();
+                        // Only set final metadata on success
+                        context.metadata({
+                            title: "RMBG (Premium)",
+                            metadata: { type: 'success', message: "Détourage HD réussi (BackgroundCut)" }
+                        });
+                        break; // Exit loop on success
+                    }
+                    catch (err) {
+                        const isFallbackable = err.message.startsWith('BGCUT_402') ||
+                            err.message.startsWith('BGCUT_429') ||
+                            err.message.startsWith('BGCUT_401');
+                        if (isFallbackable) {
+                            // console.log(`⚠️ Key ${key.substring(0, 8)} failed (${err.message}). Rotating...`); // SILENCED
+                            continue; // Try next key
+                        }
+                        else {
+                            throw err; // Fatal error (file size etc)
+                        }
+                    }
+                }
+            }
+            // 2. Fallback to Free Provider if no result yet
+            if (!resultBuffer) {
+                if (effectiveProvider === 'backgroundcut' && provider !== 'auto') {
+                    throw new Error('All provided keys failed or are expired.');
+                }
+                if (effectiveProvider === 'backgroundcut') {
+                    emitStatusToast('warning', 'Toutes les clés ont échoué. Mode Gratuit activé.', '⚠️ Fallback');
+                    // console.log('⚠️ All BackgroundCut keys failed. Falling back to free provider.'); // SILENCED
+                    fallbackUsed = true;
+                }
+                else {
+                    emitStatusToast('info', `Détourage via API Gratuite: ${basename}`, '✂️ Free RMBG');
+                }
+                resultBuffer = await removeViaCut(imageData, basename, mimeType);
+                context.metadata({
+                    title: "RMBG (Free)",
+                    metadata: { type: 'success', message: "Détourage Standard réussi" }
+                });
+                usedProvider = 'cut (free)';
+            }
+            if (!resultBuffer || resultBuffer.length < 100) {
+                return `❌ Background removal returned invalid data.`;
+            }
+            const finalPath = path.resolve(outputPath);
+            fs.writeFileSync(finalPath, resultBuffer);
+            // Double check existence
+            if (!fs.existsSync(finalPath)) {
+                throw new Error(`File write failed at: ${finalPath}`);
+            }
+            const dims = getImageSize(finalPath);
+            const dimStr = dims ? `${dims.width}×${dims.height}` : 'N/A';
+            const lines = [
+                `✂️ Background Removed`,
+                `━━━━━━━━━━━━━━━━━━━━━`,
+                `Input: ${basename} (${formatFileSize(inputStats.size)})`,
+                `Output: ${finalPath}`,
+                `Size: ${formatFileSize(resultBuffer.length)}`,
+                `Dimensions: ${dimStr}`,
+                `Format: ${outputExt.toUpperCase()} (transparent)`,
+                `Provider: ${usedProvider}`,
+                `Cost: Free`,
+            ];
+            if (fallbackUsed) {
+                lines.push(``, `⚠️ BackgroundCut key may be expired/rate-limited. Check with \`rmbg_keys action=list\``);
+            }
+            // Add info message for users without key
+            if (keysToCheck.length === 0 && usedProvider.includes('free')) {
+                lines.push(``, `💡 Tip: Add a BackgroundCut key for faster HD results: \`rmbg_keys action=add key=...\``);
+            }
+            return lines.join('\n');
+        }
+        catch (err) {
+            if (err.message.includes('429') || err.message.includes('rate')) {
+                return `⏳ Rate limited. Please try again in 30 seconds.`;
+            }
+            if (err.message.startsWith('BGCUT_402')) {
+                return `💳 BackgroundCut: No credits remaining. Add a new key or wait for renewal.\nRun: \`rmbg_keys action=add key=...\``;
+            }
+            return `❌ Background Removal Error: ${err.message}`;
+        }
+    },
+});

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

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

package/dist/tools/power/rmbg_keys.js

@@ -0,0 +1,78 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import * as fs from 'fs';
+import * as path from 'path';
+// ─── Shared Logic (Duplicated from rmbg to avoid circular deps if not using shared.ts for this) ──
+const KEYS_FILE = path.join(process.env.HOME || process.env.USERPROFILE || '/tmp', '.pollinations', 'backgroundcut_keys.json');
+function loadKeys() {
+    try {
+        if (fs.existsSync(KEYS_FILE)) {
+            return JSON.parse(fs.readFileSync(KEYS_FILE, 'utf-8'));
+        }
+    }
+    catch { }
+    return { keys: [], currentIndex: 0 };
+}
+function saveKeys(store) {
+    try {
+        const dir = path.dirname(KEYS_FILE);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(KEYS_FILE, JSON.stringify(store, null, 2));
+    }
+    catch { }
+}
+// ─── Tool Definition ────────────────────────────────────────────────────────
+export const rmbgKeysTool = tool({
+    description: `Manage BackgroundCut API keys for the remove_background tool.
+Allows adding, listing, removing, and clearing keys.
+Keys are stored locally in ~/.pollinations/backgroundcut_keys.json`,
+    args: {
+        action: tool.schema.string().describe('Action to perform: "list", "add", "remove", "clear"'), // Removed .enum()
+        key: tool.schema.string().optional().describe('API Key to add or remove (required for add/remove)'),
+    },
+    async execute(args, context) {
+        const action = args.action.toLowerCase();
+        let store = loadKeys();
+        switch (action) {
+            case 'list':
+                if (store.keys.length === 0) {
+                    return `🔑 No keys stored. Using free provider (cut).`;
+                }
+                const maskedKeys = store.keys.map((k, i) => {
+                    const active = i === store.currentIndex ? ' (active)' : '';
+                    return `   ${i + 1}. ${k.substring(0, 8)}...${k.substring(k.length - 4)}${active}`;
+                });
+                return `🔑 BackgroundCut Keys: ${store.keys.length} stored\n${maskedKeys.join('\n')}`;
+            case 'add':
+                if (!args.key)
+                    return `❌ Error: Missing 'key' argument for add action.`;
+                if (store.keys.includes(args.key))
+                    return `⚠️ Key already exists.`;
+                store.keys.push(args.key);
+                saveKeys(store);
+                context.metadata({
+                    title: '🔑 Key Added',
+                    metadata: { type: 'success', message: 'BackgroundCut key stored successfully' }
+                });
+                return `✅ Key added! Total keys: ${store.keys.length}.`;
+            case 'remove':
+                if (!args.key)
+                    return `❌ Error: Missing 'key' argument for remove action.`;
+                const initialLen = store.keys.length;
+                store.keys = store.keys.filter(k => k !== args.key);
+                if (store.keys.length === initialLen)
+                    return `⚠️ Key not found.`;
+                // Reset index if out of bounds
+                if (store.currentIndex >= store.keys.length)
+                    store.currentIndex = 0;
+                saveKeys(store);
+                return `🗑️ Key removed. Remaining: ${store.keys.length}`;
+            case 'clear':
+                store = { keys: [], currentIndex: 0 };
+                saveKeys(store);
+                return `🗑️ All keys cleared. Reverting to free provider.`;
+            default:
+                return `❌ Unknown action: ${action}. Use list, add, remove, clear.`;
+        }
+    }
+});