opencode-pollinations-plugin 6.0.0-beta.3 → 6.0.0-beta.6

package/dist/index.js

@@ -3,9 +3,9 @@ import * as fs from 'fs';
 import { generatePollinationsConfig } from './server/generate-config.js';
 import { loadConfig } from './server/config.js';
 import { handleChatCompletion } from './server/proxy.js';
-import { createToastHooks, setGlobalClient } from './server/toast.js';
+import { createToastHooks, createToolHooks, setGlobalClient } from './server/toast.js';
 import { createStatusHooks } from './server/status.js';
-import { createCommandHooks } from './server/commands.js';
+import { createCommandHooks, setClientForCommands } from './server/commands.js';
 import { createToolRegistry } from './tools/index.js';
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
@@ -83,6 +83,7 @@ export const PollinationsPlugin = async (ctx) => {
     const port = await startProxy();
     const localBaseUrl = `http://127.0.0.1:${port}/v1`;
     setGlobalClient(ctx.client);
+    setClientForCommands(ctx.client);
     const toastHooks = createToastHooks(ctx.client);
     const commandHooks = createCommandHooks();
     // Build tool registry (conditional on API key presence)
@@ -112,6 +113,7 @@ export const PollinationsPlugin = async (ctx) => {
             log(`[Hook] Registered ${Object.keys(modelsObj).length} models.`);
         },
         ...toastHooks,
+        ...createToolHooks(ctx.client),
         ...createStatusHooks(ctx.client),
         ...commandHooks
     };

package/dist/server/commands.d.ts

@@ -9,8 +9,10 @@ interface CommandResult {
     response?: string;
     error?: string;
 }
+export declare function setClientForCommands(client: any): void;
 export declare function handleCommand(command: string): Promise<CommandResult>;
 export declare function createCommandHooks(): {
     'tui.command.execute': (input: any, output: any) => Promise<void>;
+    'command.execute.before': (input: any, output: any) => Promise<void>;
 };
 export {};

package/dist/server/commands.js

@@ -130,6 +130,10 @@ function calculateCurrentPeriodStats(usage, lastReset, tierLimit) {
     };
 }
 // === COMMAND HANDLER ===
+let globalClient = null;
+export function setClientForCommands(client) {
+    globalClient = client;
+}
 export async function handleCommand(command) {
     const parts = command.trim().split(/\s+/);
     if (!parts[0].startsWith('/poll')) {
@@ -150,6 +154,22 @@ export async function handleCommand(command) {
             return handleConfigCommand(args);
         case 'help':
             return handleHelpCommand();
+        case 'addKey': // Internal command for UI
+            if (globalClient) {
+                globalClient.tui.appendPrompt({ value: "/pollinations rmbg_key_add " }); // Using the old command? No, use tool?
+                // Wait, tools are not commands.
+                // But we removed rmbg_key_add command!
+                // We should instruct user to use the tool?
+                // Or user types: rmbg_keys { action: "add", key: "..." }
+                // That's painful to type.
+                // Can we alias a command to a tool call?
+                // /pollinations rmbg_key_add is GONE.
+                // Let's re-introduce a helper command just for this UI flow?
+                // Or better: appendPrompt({ value: 'rmbg_keys { action: "add", key: "' });
+                globalClient.tui.appendPrompt({ value: 'rmbg_keys { action: "add", key: "' });
+                return { handled: true };
+            }
+            return { handled: true, error: "TUI not available" };
         default:
             return {
                 handled: true,
@@ -442,17 +462,21 @@ function handleConfigCommand(args) {
 }
 function handleHelpCommand() {
     const help = `
-### 🌸 Pollinations Plugin - Commandes V5
+### 🌸 Pollinations Plugin - Commandes V6
 
+**Mode & Usage**
 - **\`/pollinations mode [mode]\`**: Change le mode (manual, alwaysfree, pro).
 - **\`/pollinations usage [full]\`**: Affiche le dashboard (full = détail).
-- **\`/pollinations fallback <main> [agent]\`**: Configure le Safety Net (Free).
+- **\`/pollinations fallback <main> [agent]\`**: Configure le Safety Net.
+
+**Configuration**
 - **\`/pollinations config [key] [value]\`**:
-  - \`status_gui\`: none, alert, all (Status Dashboard).
-  - \`logs_gui\`: none, error, verbose (Logs Techniques).
-  - \`threshold_tier\`: 0-100 (Alerte %).
-  - \`threshold_wallet\`: 0-100 (Safety Net %).
-  - \`status_bar\`: true/false (Widget).
+  - \`status_gui\`: none, alert, all
+  - \`logs_gui\`: none, error, verbose
+  - \`threshold_tier\` / \`threshold_wallet\`: 0-100
+  - \`status_bar\`: true/false
+
+> 💡 **RMBG keys**: Use the \`rmbg_keys\` tool (works with any model).
 `.trim();
     return { handled: true, response: help };
 }
@@ -460,16 +484,44 @@ function handleHelpCommand() {
 export function createCommandHooks() {
     return {
         'tui.command.execute': async (input, output) => {
-            const result = await handleCommand(input.command);
-            if (result.handled) {
-                output.handled = true;
-                if (result.response) {
-                    output.response = result.response;
-                }
-                if (result.error) {
-                    output.error = result.error;
+            if (!input.command.startsWith('/pollinations')) {
+                return;
+            }
+            try {
+                // Parse command
+                const rawArgs = input.command.replace('/pollinations', '').trim();
+                const result = await handleCommand(rawArgs);
+                if (result.handled) {
+                    if (result.error) {
+                        output.error = `❌ **Erreur:** ${result.error}`;
+                    }
+                    else if (result.response) {
+                        output.response = result.response;
+                    }
+                    // If no response and no error, assume handled silently (like appendPrompt)
                 }
             }
+            catch (err) {
+                output.error = `❌ **Erreur Critique:** ${err.message}`;
+            }
+        },
+        // Hook for UI Commands (Palette / Buttons)
+        'command.execute.before': async (input, output) => {
+            const cmd = input.command;
+            if (cmd === 'pollinations.addKey') {
+                handleCommand('addKey'); // Trigger UI helper
+            }
+            else if (cmd === 'pollinations.usage') {
+                const res = await handleCommand('usage');
+                // For native commands, we might need a different way to show output if not in chat context
+                // But here we are likely in a context where we can't easily hijack output unless we use a toast or open a file?
+                // Let's use toast for simple feedback or appendPrompt for complex interaction.
+                if (res.response)
+                    globalClient?.tui.showToast({ title: "Pollinations Usage", metadata: { type: 'info', message: "Usage info sent to chat/logs" } });
+            }
+            else if (cmd === 'pollinations.mode') {
+                globalClient?.tui.appendPrompt({ value: "/pollinations mode " });
+            }
         }
     };
 }

package/dist/server/toast.d.ts

@@ -4,3 +4,6 @@ export declare function emitStatusToast(type: 'info' | 'warning' | 'error' | 'su
 export declare function createToastHooks(client: any): {
     'session.idle': ({ event }: any) => Promise<void>;
 };
+export declare function createToolHooks(client: any): {
+    'tool.execute.after': (input: any, output: any) => Promise<void>;
+};

package/dist/server/toast.js

@@ -76,3 +76,19 @@ export function createToastHooks(client) {
         }
     };
 }
+// 3. CANAL TOOLS (Natif)
+export function createToolHooks(client) {
+    return {
+        'tool.execute.after': async (input, output) => {
+            // Check for metadata in the output
+            if (output.metadata && output.metadata.message) {
+                const meta = output.metadata;
+                const type = meta.type || 'info';
+                // If title is not in metadata, try to use the one from output or default
+                const title = meta.title || output.title || 'Pollinations Tool';
+                // Emit the toast
+                emitStatusToast(type, meta.message, title);
+            }
+        }
+    };
+}

package/dist/tools/index.js

@@ -15,6 +15,7 @@ import { fileToUrlTool } from './power/file_to_url.js';
 import { removeBackgroundTool } from './power/remove_background.js';
 import { extractFramesTool } from './power/extract_frames.js';
 import { extractAudioTool } from './power/extract_audio.js';
+import { rmbgKeysTool } from './power/rmbg_keys.js';
 // === ENTER TOOLS (Require API key) ===
 // Phase 4D: Pollinations tools — TO BE IMPLEMENTED
 // import { genImageTool } from './pollinations/gen_image.js';
@@ -57,6 +58,7 @@ export function createToolRegistry() {
     tools['remove_background'] = removeBackgroundTool;
     tools['extract_frames'] = extractFramesTool;
     tools['extract_audio'] = extractAudioTool;
+    tools['rmbg_keys'] = rmbgKeysTool;
     // gen_image (free version) — TODO Phase 4D
     // tools['gen_image'] = genImageTool;
     log(`Free tools injected: ${Object.keys(tools).length}`);

package/dist/tools/power/remove_background.js

@@ -3,66 +3,167 @@ import * as https from 'https';
 import * as fs from 'fs';
 import * as path from 'path';
 import { resolveOutputDir, formatFileSize, TOOL_DIRS } from '../shared.js';
-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) {
+// ─── 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 getNextKey() {
+    const store = loadKeys();
+    if (store.keys.length === 0)
+        return null;
+    const key = store.keys[store.currentIndex % store.keys.length];
+    // Rotate for next call
+    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 { }
+    return key;
+}
+// ─── HTTP Helpers ────────────────────────────────────────────────────────────
+function httpRequest(url, options, body) {
     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 req = https.request(url, options, (res) => {
             const chunks = [];
             res.on('data', (chunk) => chunks.push(chunk));
-            res.on('end', () => resolve(Buffer.concat(chunks)));
+            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('Background removal timeout (60s)'));
-        });
-        req.write(body);
+        req.setTimeout(60000, () => { req.destroy(); reject(new Error('Request timeout (60s)')); });
+        if (body)
+            req.write(body);
         req.end();
     });
 }
-// formatFileSize imported from shared.ts
+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);
+    });
+}
+// ─── 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.
-Uses AI-powered background removal (u2netp model).
-Supports PNG, JPEG, and WebP input formats.
-Free to use — no API key or pollen required.`,
+    description: `Remove the background from an image, producing a transparent PNG or WebP.
+
+**Providers:**
+- \`cut\` (default free) — Built-in u2netp AI, no API key needed. Slower, rate-limited.
+- \`backgroundcut\` — Premium API, requires API key (5$ free credits at signup on backgroundcut.co). Much faster, higher quality.
+
+**Setup:** Use \`/poll key add backgroundcut <your_key>\` to store your BackgroundCut API key.
+Multiple keys supported with automatic rotation.
+
+**Auto mode:** If a BackgroundCut key is stored, uses it first. Falls back to free provider on error (402/429).`,
     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'),
+        filename: tool.schema.string().optional().describe('Custom output filename (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)'),
+        api_key: tool.schema.string().optional().describe('BackgroundCut API key (overrides stored keys)'),
+        quality: tool.schema.string().optional().describe('BackgroundCut quality: "low", "medium" (default), "high"'),
+        return_format: tool.schema.string().optional().describe('Output format: "png" (default), "webp"'),
+        max_resolution: tool.schema.number().optional().describe('Max output resolution in pixels (e.g., 4000000 for 4MP). BackgroundCut only.'),
     },
     async execute(args, context) {
-        // Validate input
+        // ── Validate input ──
         if (!fs.existsSync(args.image_path)) {
             return `❌ File not found: ${args.image_path}`;
         }
@@ -71,34 +172,124 @@ Free to use — no API key or pollen required.`,
             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`;
+        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 key (arg > stored > none) ──
+        let bgcutKey = args.api_key || null;
+        if (!bgcutKey)
+            bgcutKey = getNextKey();
+        // ── Determine effective provider ──
+        let effectiveProvider = provider;
+        if (provider === 'auto') {
+            effectiveProvider = bgcutKey ? 'backgroundcut' : 'cut';
+        }
+        // ── Info message when no BackgroundCut key ──
+        if (!bgcutKey && (provider === 'auto' || provider === 'backgroundcut')) {
+            console.log("No BackgroundCut key found. Using free provider.");
+            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: \`/poll key add backgroundcut YOUR_API_KEY\``,
+                `3. Multiple keys supported — they rotate automatically!`,
+            ].join('\n');
+            if (provider === 'backgroundcut') {
+                return `❌ BackgroundCut provider selected but no API key found.\n\n${noKeyMsg}`;
+            }
+            // In auto mode, we continue with free provider but show the message
+            context.metadata({ title: `⚡ Using free provider (no BackgroundCut key)` });
         }
+        // ── Output path ──
         const outputDir = resolveOutputDir(TOOL_DIRS.rembg, args.output_path);
         const safeName = args.filename
             ? args.filename.replace(/[^a-zA-Z0-9_-]/g, '_')
             : `${path.basename(args.image_path, ext)}_nobg`;
-        const outputPath = path.join(outputDir, `${safeName}.png`);
+        const outputExt = returnFormat === 'webp' && effectiveProvider === 'backgroundcut' ? 'webp' : 'png';
+        const outputPath = path.join(outputDir, `${safeName}.${outputExt}`);
+        // ── Execute ──
         try {
-            context.metadata({ title: `✂️ Removing background: ${path.basename(args.image_path)}` });
-            const resultBuffer = await removeBackground(args.image_path);
+            let resultBuffer;
+            let usedProvider;
+            let fallbackUsed = false;
+            if (effectiveProvider === 'backgroundcut' && bgcutKey) {
+                context.metadata({ title: `✂️ BackgroundCut: ${basename}` }); // 1. TRY BACKGROUNDCUT
+                try {
+                    console.log(`[RMBG] Attempting BackgroundCut with key ${bgcutKey.substring(0, 8)}...`);
+                    resultBuffer = await removeViaBackgroundCut(imageData, basename, mimeType, bgcutKey, quality, returnFormat, args.max_resolution);
+                    context.metadata({
+                        title: "RMBG (Premium)",
+                        metadata: { type: 'success', message: "Détourage HD réussi (BackgroundCut)" }
+                    });
+                    usedProvider = 'backgroundcut';
+                }
+                catch (err) {
+                    // Fallback to CUT on specific errors
+                    const isFallbackable = err.message.startsWith('BGCUT_402') ||
+                        err.message.startsWith('BGCUT_429') ||
+                        err.message.startsWith('BGCUT_401');
+                    if (isFallbackable && provider === 'auto') {
+                        context.metadata({ title: `⚠️ BackgroundCut failed (${err.message.split(':')[0]}), falling back to free...` });
+                        resultBuffer = await removeViaCut(imageData, basename, mimeType);
+                        usedProvider = 'cut (fallback)';
+                        fallbackUsed = true;
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+            }
+            else {
+                context.metadata({ title: `✂️ Free RMBG: ${basename}` });
+                resultBuffer = await removeViaCut(imageData, basename, mimeType);
+                // 2. FREE PROVIDER EXECUTION
+                context.metadata({
+                    title: "RMBG (Free)",
+                    metadata: { type: 'success', message: "Détourage Standard réussi" }
+                });
+                usedProvider = 'cut (free)';
+            }
             if (resultBuffer.length < 100) {
                 return `❌ Background removal returned invalid data. The API might be temporarily unavailable.`;
             }
             fs.writeFileSync(outputPath, resultBuffer);
-            return [
+            const lines = [
                 `✂️ Background Removed`,
                 `━━━━━━━━━━━━━━━━━━━━━`,
-                `Input: ${path.basename(args.image_path)} (${formatFileSize(inputStats.size)})`,
+                `Input: ${basename} (${formatFileSize(inputStats.size)})`,
                 `Output: ${outputPath}`,
                 `Size: ${formatFileSize(resultBuffer.length)}`,
-                `Format: PNG (transparent)`,
+                `Format: ${outputExt.toUpperCase()} (transparent)`,
+                `Provider: ${usedProvider}`,
                 `Cost: Free`,
-            ].join('\n');
+            ];
+            if (fallbackUsed) {
+                lines.push(``, `⚠️ BackgroundCut key may be expired/rate-limited. Check with \`/poll key list backgroundcut\``);
+            }
+            // Add info message for users without key
+            if (!bgcutKey && usedProvider.includes('free')) {
+                lines.push(``, `💡 Tip: Add a BackgroundCut key for faster HD results: \`/poll key add backgroundcut <key>\``);
+            }
+            return lines.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 `⏳ 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: \`/poll key add backgroundcut <new_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,140 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+// ─── Key Storage (shared with remove_background.ts) ──────────────────────────
+const KEYS_FILE = path.join(os.homedir(), '.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) {
+    const dir = path.dirname(KEYS_FILE);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(KEYS_FILE, JSON.stringify(store, null, 2));
+}
+// ─── Tool ────────────────────────────────────────────────────────────────────
+export const rmbgKeysTool = tool({
+    description: `Manage BackgroundCut API keys for the remove_background tool.
+
+**Actions:**
+- \`add\` — Add a new API key (supports multiple keys with auto-rotation).
+- \`list\` — Show all stored keys and which one is next.
+- \`clear\` — Remove all stored keys (reverts to free provider).
+
+**Why?** The remove_background tool has 2 providers:
+- **Free** (cut.esprit-artificiel.com): No key needed, but slow and rate-limited.
+- **BackgroundCut** (backgroundcut.co): Fast, HD, up to 12MP. Requires an API key.
+
+**Get a key:** Sign up at https://backgroundcut.co → 5$ free credits (60 days).
+Keys rotate automatically — add multiple keys for uninterrupted usage.`,
+    args: {
+        action: tool.schema.string().describe('Action: "add", "list", or "clear"'),
+        key: tool.schema.string().optional().describe('API key to add (required for "add" action)'),
+    },
+    async execute(args, context) {
+        const action = (args.action || '').toLowerCase();
+        // ── ADD ──
+        if (action === 'add') {
+            if (!args.key) {
+                return [
+                    `❌ **Missing key.** Usage:`,
+                    `\`rmbg_keys { action: "add", key: "YOUR_API_KEY" }\``,
+                    ``,
+                    `🔑 Get your key at https://backgroundcut.co (5$ free, 60 days).`,
+                ].join('\n');
+            }
+            // Validate format (hex, 30-60 chars)
+            if (!/^[a-f0-9]{30,60}$/i.test(args.key)) {
+                context.metadata({
+                    metadata: { type: 'error', message: "Clé BackgroundCut invalide (format hex incorrect)." }
+                });
+                return `❌ Invalid key format. BackgroundCut keys are 40-character hexadecimal strings.`;
+            }
+            const store = loadKeys();
+            if (store.keys.includes(args.key)) {
+                context.metadata({
+                    metadata: { type: 'warning', message: "Cette clé est déjà enregistrée." }
+                });
+                return `⚠️ This key is already stored (${store.keys.length} key(s) total).`;
+            }
+            store.keys.push(args.key);
+            saveKeys(store);
+            const masked = args.key.substring(0, 8) + '...' + args.key.substring(args.key.length - 4);
+            context.metadata({
+                title: "Pollinations Keys",
+                metadata: { type: 'success', message: `Clé ajoutée ! (${store.keys.length} actives)` }
+            });
+            return [
+                `✅ **BackgroundCut key added!**`,
+                ``,
+                `🔑 Key: \`${masked}\``,
+                `📦 Total: ${store.keys.length} key(s) — auto-rotation active`,
+                ``,
+                `The \`remove_background\` tool will now use BackgroundCut automatically.`,
+                `Faster processing, HD quality, up to 12MP.`,
+            ].join('\n');
+        }
+        // ── LIST ──
+        if (action === 'list') {
+            const store = loadKeys();
+            if (store.keys.length === 0) {
+                return [
+                    `📭 **No BackgroundCut keys stored.**`,
+                    ``,
+                    `The \`remove_background\` tool uses the free provider (slower, rate-limited).`,
+                    ``,
+                    `🚀 **Want faster, HD results?**`,
+                    `1. Sign up at https://backgroundcut.co (5$ free credits, 60 days)`,
+                    `2. Add your key: \`rmbg_keys { action: "add", key: "YOUR_KEY" }\``,
+                    `3. Multiple keys supported — they rotate automatically!`,
+                ].join('\n');
+            }
+            const lines = [
+                `🔑 **BackgroundCut Keys** (${store.keys.length} stored)`,
+                ``,
+            ];
+            store.keys.forEach((k, i) => {
+                const masked = k.substring(0, 8) + '...' + k.substring(k.length - 4);
+                const marker = i === (store.currentIndex % store.keys.length) ? ' ← next' : '';
+                lines.push(`${i + 1}. \`${masked}\`${marker}`);
+            });
+            lines.push(``, `Auto-rotation: next call uses key #${(store.currentIndex % store.keys.length) + 1}.`, `To clear all: \`rmbg_keys { action: "clear" }\``);
+            return lines.join('\n');
+        }
+        // ── CLEAR ──
+        if (action === 'clear') {
+            const store = loadKeys();
+            const count = store.keys.length;
+            saveKeys({ keys: [], currentIndex: 0 });
+            if (count === 0) {
+                return `📭 No keys to clear — already empty.`;
+            }
+            context.metadata({
+                title: "Pollinations Keys",
+                metadata: { type: 'info', message: "Toutes les clés BackgroundCut ont été supprimées." }
+            });
+            return [
+                `🗑️ **${count} BackgroundCut key(s) cleared.**`,
+                ``,
+                `The \`remove_background\` tool will now use the free provider.`,
+                `Add keys again anytime: \`rmbg_keys { action: "add", key: "..." }\``,
+            ].join('\n');
+        }
+        // ── UNKNOWN ──
+        return [
+            `❌ Unknown action: "${action}"`,
+            ``,
+            `Available actions:`,
+            `- \`add\` — Add a BackgroundCut API key`,
+            `- \`list\` — Show stored keys`,
+            `- \`clear\` — Remove all keys`,
+        ].join('\n');
+    },
+});

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "opencode-pollinations-plugin",
     "displayName": "Pollinations AI (V5.9)",
-    "version": "6.0.0-beta.3",
+    "version": "6.0.0-beta.6",
     "description": "Native Pollinations.ai Provider Plugin for OpenCode",
     "publisher": "pollinations",
     "repository": {
@@ -41,6 +41,10 @@
             {
                 "command": "pollinations.usage",
                 "title": "Pollinations: Show Usage"
+            },
+            {
+                "command": "pollinations.addKey",
+                "title": "Pollinations: Add BackgroundCut Key"
             }
         ]
     },