opencode-pollinations-plugin 6.1.0-beta.8 → 6.2.0

package/dist/tools/design/gen_palette.js

@@ -0,0 +1,182 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import * as fs from 'fs';
+import * as path from 'path';
+import { resolveOutputDir, TOOL_DIRS } from '../shared.js';
+function hexToHSL(hex) {
+    hex = hex.replace('#', '');
+    if (hex.length === 3)
+        hex = hex.split('').map(c => c + c).join('');
+    const r = parseInt(hex.substring(0, 2), 16) / 255;
+    const g = parseInt(hex.substring(2, 4), 16) / 255;
+    const b = parseInt(hex.substring(4, 6), 16) / 255;
+    const max = Math.max(r, g, b), min = Math.min(r, g, b);
+    let h = 0, s = 0;
+    const l = (max + min) / 2;
+    if (max !== min) {
+        const d = max - min;
+        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+        switch (max) {
+            case r:
+                h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+                break;
+            case g:
+                h = ((b - r) / d + 2) / 6;
+                break;
+            case b:
+                h = ((r - g) / d + 4) / 6;
+                break;
+        }
+    }
+    return { h: Math.round(h * 360), s: Math.round(s * 100), l: Math.round(l * 100) };
+}
+function hslToHex(h, s, l) {
+    s /= 100;
+    l /= 100;
+    const a = s * Math.min(l, 1 - l);
+    const f = (n) => {
+        const k = (n + h / 30) % 12;
+        const color = l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
+        return Math.round(255 * color).toString(16).padStart(2, '0');
+    };
+    return `#${f(0)}${f(8)}${f(4)}`;
+}
+function generatePalette(baseHex, scheme, count) {
+    const base = hexToHSL(baseHex);
+    const colors = [];
+    switch (scheme) {
+        case 'complementary':
+            colors.push({ hex: baseHex, role: 'Base' });
+            colors.push({ hex: hslToHex((base.h + 180) % 360, base.s, base.l), role: 'Complement' });
+            // Fill shades
+            for (let i = 2; i < count; i++) {
+                const lShift = base.l + (i % 2 === 0 ? 15 : -15) * Math.ceil(i / 2);
+                colors.push({ hex: hslToHex(base.h, base.s, Math.max(10, Math.min(90, lShift))), role: `Shade ${i - 1}` });
+            }
+            break;
+        case 'analogous':
+            for (let i = 0; i < count; i++) {
+                const offset = (i - Math.floor(count / 2)) * 30;
+                colors.push({
+                    hex: hslToHex((base.h + offset + 360) % 360, base.s, base.l),
+                    role: offset === 0 ? 'Base' : `${offset > 0 ? '+' : ''}${offset}°`
+                });
+            }
+            break;
+        case 'triadic':
+            colors.push({ hex: baseHex, role: 'Base' });
+            colors.push({ hex: hslToHex((base.h + 120) % 360, base.s, base.l), role: 'Triad +120°' });
+            colors.push({ hex: hslToHex((base.h + 240) % 360, base.s, base.l), role: 'Triad +240°' });
+            for (let i = 3; i < count; i++) {
+                const lShift = base.l + (i % 2 === 0 ? 12 : -12) * Math.ceil((i - 2) / 2);
+                colors.push({ hex: hslToHex((base.h + (i * 120)) % 360, base.s, Math.max(10, Math.min(90, lShift))), role: `Accent ${i - 2}` });
+            }
+            break;
+        case 'split-complementary':
+            colors.push({ hex: baseHex, role: 'Base' });
+            colors.push({ hex: hslToHex((base.h + 150) % 360, base.s, base.l), role: 'Split +150°' });
+            colors.push({ hex: hslToHex((base.h + 210) % 360, base.s, base.l), role: 'Split +210°' });
+            for (let i = 3; i < count; i++) {
+                colors.push({ hex: hslToHex(base.h, base.s, Math.max(10, Math.min(90, base.l + (i * 10 - 30)))), role: `Tone ${i - 2}` });
+            }
+            break;
+        case 'monochromatic':
+        default:
+            for (let i = 0; i < count; i++) {
+                const l = Math.round(15 + (i / (count - 1)) * 70); // 15% to 85%
+                colors.push({
+                    hex: hslToHex(base.h, base.s, l),
+                    role: l < base.l ? `Dark ${Math.abs(i - Math.floor(count / 2))}` : l === base.l ? 'Base' : `Light ${Math.abs(i - Math.floor(count / 2))}`,
+                });
+            }
+            // Mark closest to base
+            let closestIdx = 0;
+            let closestDiff = Infinity;
+            colors.forEach((c, i) => {
+                const diff = Math.abs(hexToHSL(c.hex).l - base.l);
+                if (diff < closestDiff) {
+                    closestDiff = diff;
+                    closestIdx = i;
+                }
+            });
+            colors[closestIdx].role = 'Base';
+            break;
+    }
+    return colors.slice(0, count);
+}
+function generateSVG(colors) {
+    const swatchW = 120;
+    const swatchH = 80;
+    const gap = 8;
+    const totalW = colors.length * (swatchW + gap) - gap + 40;
+    const totalH = swatchH + 60;
+    const swatches = colors.map((c, i) => {
+        const x = 20 + i * (swatchW + gap);
+        const textColor = hexToHSL(c.hex).l > 50 ? '#1a1a1a' : '#ffffff';
+        return `
+    <rect x="${x}" y="20" width="${swatchW}" height="${swatchH}" rx="8" fill="${c.hex}" stroke="#333" stroke-width="1"/>
+    <text x="${x + swatchW / 2}" y="${swatchH / 2 + 15}" text-anchor="middle" fill="${textColor}" font-family="monospace" font-size="13" font-weight="bold">${c.hex.toUpperCase()}</text>
+    <text x="${x + swatchW / 2}" y="${swatchH + 38}" text-anchor="middle" fill="#666" font-family="sans-serif" font-size="11">${c.role}</text>`;
+    }).join('');
+    return `<svg xmlns="http://www.w3.org/2000/svg" width="${totalW}" height="${totalH}" viewBox="0 0 ${totalW} ${totalH}">
+  <rect width="100%" height="100%" fill="#0d0d0d" rx="12"/>
+  ${swatches}
+</svg>`;
+}
+export const genPaletteTool = tool({
+    description: `Generate a harmonious color palette from a base hex color.
+Outputs a visual SVG palette + JSON color codes. Works 100% offline.
+Schemes: monochromatic, complementary, analogous, triadic, split-complementary.
+Perfect for frontend design, branding, and UI theming.`,
+    args: {
+        color: tool.schema.string().describe('Base hex color (e.g. "#3B82F6" or "3B82F6")'),
+        scheme: tool.schema.enum(['monochromatic', 'complementary', 'analogous', 'triadic', 'split-complementary']).optional()
+            .describe('Color harmony scheme (default: analogous)'),
+        count: tool.schema.number().min(3).max(8).optional().describe('Number of colors (default: 5, max: 8)'),
+        filename: tool.schema.string().optional().describe('Custom filename (without extension). Auto-generated if omitted'),
+        output_path: tool.schema.string().optional().describe('Custom output directory. Default: ~/Downloads/pollinations/palettes/'),
+    },
+    async execute(args, context) {
+        const scheme = args.scheme || 'analogous';
+        const count = args.count || 5;
+        // Normalize hex
+        let hex = args.color.trim();
+        if (!hex.startsWith('#'))
+            hex = '#' + hex;
+        if (!/^#[0-9a-fA-F]{3,6}$/.test(hex)) {
+            return `❌ Invalid hex color: "${args.color}". Use format: #3B82F6 or 3B82F6`;
+        }
+        if (hex.length === 4)
+            hex = '#' + hex[1] + hex[1] + hex[2] + hex[2] + hex[3] + hex[3];
+        // Generate palette
+        const colors = generatePalette(hex, scheme, count);
+        const outputDir = resolveOutputDir(TOOL_DIRS.palettes, args.output_path);
+        // Save SVG
+        const safeName = args.filename
+            ? args.filename.replace(/[^a-zA-Z0-9_-]/g, '_')
+            : `palette_${hex.replace('#', '')}_${scheme}`;
+        const svgPath = path.join(outputDir, `${safeName}.svg`);
+        const svg = generateSVG(colors);
+        fs.writeFileSync(svgPath, svg);
+        // Build CSS custom properties snippet
+        const cssVars = colors.map((c, i) => `  --color-${i + 1}: ${c.hex};`).join('\n');
+        context.metadata({ title: `🎨 Palette: ${scheme} from ${hex}` });
+        const colorTable = colors.map(c => `  ${c.hex.toUpperCase()}  ${c.role}`).join('\n');
+        return [
+            `🎨 Color Palette Generated`,
+            `━━━━━━━━━━━━━━━━━━━━━━━━━`,
+            `Base: ${hex.toUpperCase()}`,
+            `Scheme: ${scheme}`,
+            `Colors (${count}):`,
+            colorTable,
+            ``,
+            `File: ${svgPath}`,
+            ``,
+            `CSS Variables:`,
+            `:root {`,
+            cssVars,
+            `}`,
+            ``,
+            `Cost: Free (local computation)`,
+        ].join('\n');
+    },
+});

package/dist/tools/design/gen_qrcode.d.ts

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

package/dist/tools/design/gen_qrcode.js

@@ -0,0 +1,50 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import * as QRCode from 'qrcode';
+import * as fs from 'fs';
+import * as path from 'path';
+import { resolveOutputDir, TOOL_DIRS } from '../shared.js';
+export const genQrcodeTool = tool({
+    description: `Generate a QR code image from text, URL, or WiFi credentials. 
+Outputs a PNG file saved locally. Works 100% offline, no API key needed.
+Examples: URLs, plain text, WiFi (format: WIFI:T:WPA;S:NetworkName;P:Password;;)`,
+    args: {
+        content: tool.schema.string().describe('The text, URL, or WiFi string to encode into a QR code'),
+        size: tool.schema.number().min(128).max(2048).optional().describe('QR code size in pixels (default: 512)'),
+        filename: tool.schema.string().optional().describe('Custom filename (without extension). Auto-generated if omitted'),
+        output_path: tool.schema.string().optional().describe('Custom output directory. Default: ~/Downloads/pollinations/qrcodes/'),
+    },
+    async execute(args, context) {
+        const size = args.size || 512;
+        const outputDir = resolveOutputDir(TOOL_DIRS.qrcodes, args.output_path);
+        const safeName = args.filename
+            ? args.filename.replace(/[^a-zA-Z0-9_-]/g, '_')
+            : `qr_${Date.now()}`;
+        const filePath = path.join(outputDir, `${safeName}.png`);
+        try {
+            await QRCode.toFile(filePath, args.content, {
+                width: size,
+                margin: 2,
+                color: { dark: '#000000', light: '#ffffff' },
+                errorCorrectionLevel: 'M',
+            });
+            const stats = fs.statSync(filePath);
+            const fileSizeKB = (stats.size / 1024).toFixed(1);
+            const displayContent = args.content.length > 80
+                ? args.content.substring(0, 77) + '...'
+                : args.content;
+            context.metadata({ title: `🔲 QR Code: ${displayContent}` });
+            return [
+                `🔲 QR Code Généré`,
+                `━━━━━━━━━━━━━━━━━━`,
+                `Contenu: ${displayContent}`,
+                `Taille: ${size}×${size}px`,
+                `Fichier: ${filePath}`,
+                `Poids: ${fileSizeKB} KB`,
+                `Coût: Gratuit (génération locale)`,
+            ].join('\n');
+        }
+        catch (err) {
+            return `❌ Erreur QR Code: ${err.message}`;
+        }
+    },
+});

package/dist/tools/ffmpeg.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Check if ffmpeg is available in the system PATH
+ */
+export declare function hasSystemFFmpeg(): boolean;
+/**
+ * Check if ffprobe is available in the system PATH
+ */
+export declare function hasSystemFFprobe(): boolean;
+/**
+ * Get cross-platform installation instructions
+ */
+export declare function getFFmpegInstallInstructions(): string;
+/**
+ * Helper to run ffmpeg commands safely
+ */
+export declare function runFFmpeg(args: string[], options?: {
+    timeout?: number;
+}): void;
+/**
+ * Helper to run ffprobe commands safely and return stdout
+ */
+export declare function runFFprobe(args: string[], options?: {
+    timeout?: number;
+}): string;

package/dist/tools/ffmpeg.js

@@ -0,0 +1,54 @@
+import { spawnSync } from 'child_process';
+/**
+ * Check if ffmpeg is available in the system PATH
+ */
+export function hasSystemFFmpeg() {
+    const result = spawnSync('ffmpeg', ['-version'], { stdio: 'ignore' });
+    return result.status === 0 && !result.error;
+}
+/**
+ * Check if ffprobe is available in the system PATH
+ */
+export function hasSystemFFprobe() {
+    const result = spawnSync('ffprobe', ['-version'], { stdio: 'ignore' });
+    return result.status === 0 && !result.error;
+}
+/**
+ * Get cross-platform installation instructions
+ */
+export function getFFmpegInstallInstructions() {
+    const platform = process.platform;
+    const instructions = {
+        linux: 'sudo apt install ffmpeg  (Debian/Ubuntu)\nsudo dnf install ffmpeg  (Fedora)',
+        darwin: 'brew install ffmpeg',
+        win32: 'choco install ffmpeg  (Chocolatey)\nwinget install ffmpeg  (WinGet)\nOu télécharger sur https://ffmpeg.org/download.html',
+    };
+    return instructions[platform] || 'Voir https://ffmpeg.org/download.html';
+}
+/**
+ * Helper to run ffmpeg commands safely
+ */
+export function runFFmpeg(args, options = {}) {
+    const result = spawnSync('ffmpeg', args, {
+        stdio: 'ignore',
+        timeout: options.timeout || 120000,
+    });
+    if (result.error)
+        throw result.error;
+    if (result.status !== 0)
+        throw new Error(`FFmpeg failed with code ${result.status}`);
+}
+/**
+ * Helper to run ffprobe commands safely and return stdout
+ */
+export function runFFprobe(args, options = {}) {
+    const result = spawnSync('ffprobe', args, {
+        encoding: 'utf-8',
+        timeout: options.timeout || 15000,
+    });
+    if (result.error)
+        throw result.error;
+    if (result.status !== 0)
+        throw new Error(`FFprobe failed: ${result.stderr}`);
+    return result.stdout;
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Tool Registry — Conditional Injection System
+ *
+ * Free Universe (no key): 8 tools always available
+ * Enter Universe (with key): +6 Pollinations tools
+ *
+ * Tools are injected ONCE at plugin init. Restart needed after /poll connect.
+ */
+import { polliGenImageTool } from './pollinations/gen_image.js';
+import { polliGenVideoTool } from './pollinations/gen_video.js';
+import { polliGenAudioTool } from './pollinations/gen_audio.js';
+import { polliSttTool } from './pollinations/transcribe_audio.js';
+import { polliGenMusicTool } from './pollinations/gen_music.js';
+import { polliWebSearchTool } from './pollinations/polli_web_search.js';
+import { polliBetaDiscoveryTool } from './pollinations/beta_discovery.js';
+import { polliGenConfirmTool } from './pollinations/polli_gen_confirm.js';
+import { polliStatusTool } from './pollinations/polli_status.js';
+import { polliConfigTool } from './pollinations/polli_config.js';
+/**
+ * Build the tool registry based on user's access level
+ *
+ * @returns Record<string, Tool> to be spread into the plugin's tool: {} property
+ */
+export declare function createToolRegistry(): Record<string, any>;
+export { polliGenImageTool, polliGenVideoTool, polliGenAudioTool, polliSttTool, polliGenMusicTool, polliWebSearchTool, polliBetaDiscoveryTool, polliGenConfirmTool, polliStatusTool, polliConfigTool };

package/dist/tools/index.js

@@ -0,0 +1,86 @@
+/**
+ * Tool Registry — Conditional Injection System
+ *
+ * Free Universe (no key): 8 tools always available
+ * Enter Universe (with key): +6 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';
+import { extractAudioTool } from './power/extract_audio.js';
+import { rmbgKeysTool } from './power/rmbg_keys.js';
+// === ENTER TOOLS (Require API key) ===
+import { polliGenImageTool } from './pollinations/gen_image.js';
+import { polliGenVideoTool } from './pollinations/gen_video.js';
+import { polliGenAudioTool } from './pollinations/gen_audio.js';
+import { polliSttTool } from './pollinations/transcribe_audio.js';
+import { polliGenMusicTool } from './pollinations/gen_music.js';
+import { polliWebSearchTool } from './pollinations/polli_web_search.js';
+import { polliBetaDiscoveryTool } from './pollinations/beta_discovery.js';
+import { polliGenConfirmTool } from './pollinations/polli_gen_confirm.js';
+import { polliStatusTool } from './pollinations/polli_status.js';
+import { polliConfigTool } from './pollinations/polli_config.js';
+import { log } from '../server/logger.js';
+/**
+ * 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();
+    // === FREE UNIVERSE: Always injected (8 tools) ===
+    // Design tools (3)
+    tools['gen_qrcode'] = genQrcodeTool;
+    tools['gen_diagram'] = genDiagramTool;
+    tools['gen_palette'] = genPaletteTool;
+    // Power tools (5)
+    tools['file_to_url'] = fileToUrlTool;
+    tools['remove_background'] = removeBackgroundTool;
+    tools['extract_frames'] = extractFramesTool;
+    tools['extract_audio'] = extractAudioTool;
+    tools['rmbg_keys'] = rmbgKeysTool;
+    log(`Free tools injected: ${Object.keys(tools).length}`);
+    // === ENTER UNIVERSE: Only with valid API key (+6 tools) ===
+    if (keyPresent) {
+        // Pollinations media tools
+        tools['polli_gen_image'] = polliGenImageTool;
+        tools['polli_gen_video'] = polliGenVideoTool;
+        tools['polli_gen_audio'] = polliGenAudioTool;
+        tools['polli_stt'] = polliSttTool;
+        tools['polli_gen_music'] = polliGenMusicTool;
+        // Unified search tool
+        tools['polli_web_search'] = polliWebSearchTool;
+        // Cost Guard Confirmation tool
+        tools['polli_gen_confirm'] = polliGenConfirmTool;
+        // Model API discovery & diagnostics
+        tools['polli_beta_discovery'] = polliBetaDiscoveryTool;
+        // Plugin Configuration editor (Agents)
+        tools['polli_config'] = polliConfigTool;
+        // Plugin Status / Info / Pricing helper map
+        tools['polli_status'] = polliStatusTool;
+        log(`Enter tools injected (key detected). Total: ${Object.keys(tools).length}`);
+    }
+    else {
+        // En mode gratuit, on ajoute quand meme polli_status mais restraint (il dira manque une clé pour full profile etc)
+        tools['polli_status'] = polliStatusTool;
+        log(`Enter tools SKIPPED (no key). Total: ${Object.keys(tools).length}`);
+    }
+    return tools;
+}
+// Re-export for convenience
+export { polliGenImageTool, polliGenVideoTool, polliGenAudioTool, polliSttTool, polliGenMusicTool, polliWebSearchTool, polliBetaDiscoveryTool, polliGenConfirmTool, polliStatusTool, polliConfigTool };

package/dist/tools/pollinations/beta_discovery.d.ts

@@ -0,0 +1,9 @@
+/**
+ * beta_discovery Tool (API Explorer V3 - Hybrid Probe)
+ *
+ * Combines reading the official OpenAPI Specification with active
+ * blackbox probing (triggering HTTP 400/422 ValidationErrors) to
+ * discover hidden or undocumented enums and parameters.
+ */
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const polliBetaDiscoveryTool: ToolDefinition;

package/dist/tools/pollinations/beta_discovery.js

@@ -0,0 +1,201 @@
+/**
+ * beta_discovery Tool (API Explorer V3 - Hybrid Probe)
+ *
+ * Combines reading the official OpenAPI Specification with active
+ * blackbox probing (triggering HTTP 400/422 ValidationErrors) to
+ * discover hidden or undocumented enums and parameters.
+ */
+import { tool } from '@opencode-ai/plugin/tool';
+import { emitStatusToast } from '../../server/toast.js';
+import { getApiKey } from './shared.js';
+import * as fs from 'fs';
+import * as https from 'https';
+// Primary URL for the OpenAPI spec
+const OPENAPI_URL = 'https://enter.pollinations.ai/api/docs/open-api/generate-schema';
+// Fallback local path
+const LOCAL_FALLBACK_PATH = '/home/fkomp/Bureau/oracle/Documentations/API - Severals documentations for multiples api usages/pollinations/pollinations_enter_beta/PolinationsGenBeta_api.json';
+let cachedSchema = null;
+async function fetchOpenApiSchema() {
+    if (cachedSchema)
+        return cachedSchema;
+    try {
+        if (fs.existsSync(LOCAL_FALLBACK_PATH)) {
+            const data = fs.readFileSync(LOCAL_FALLBACK_PATH, 'utf-8');
+            cachedSchema = JSON.parse(data);
+            return cachedSchema;
+        }
+    }
+    catch (e) {
+        // Fallthrough
+    }
+    try {
+        const response = await fetch(OPENAPI_URL);
+        if (!response.ok)
+            throw new Error(`HTTP ${response.status}`);
+        cachedSchema = await response.json();
+        return cachedSchema;
+    }
+    catch (e) {
+        throw new Error(`Failed to load OpenAPI Schema: ${e.message}`);
+    }
+}
+async function probeEndpoint(method, endpointUrl, payloadStr) {
+    return new Promise((resolve, reject) => {
+        const apiKey = getApiKey();
+        const urlObj = new URL(endpointUrl.startsWith('http') ? endpointUrl : `https://gen.pollinations.ai${endpointUrl.startsWith('/') ? '' : '/'}${endpointUrl}`);
+        const options = {
+            method: method,
+            headers: {
+                'User-Agent': 'OpenCode-Probe-Tool/3.0',
+                'Accept': 'application/json'
+            }
+        };
+        if (apiKey) {
+            options.headers['Authorization'] = `Bearer ${apiKey}`;
+        }
+        let postData;
+        if (method === 'POST') {
+            options.headers['Content-Type'] = 'application/json';
+            if (payloadStr) {
+                try {
+                    // Try to parse just to validate it's json, but send the string
+                    JSON.parse(payloadStr);
+                    postData = payloadStr;
+                    options.headers['Content-Length'] = Buffer.byteLength(postData);
+                }
+                catch (e) {
+                    return resolve(`❌ Error: payload_json must be a valid JSON string. Parse error: ${e.message}`);
+                }
+            }
+            else {
+                postData = '{}';
+                options.headers['Content-Length'] = Buffer.byteLength(postData);
+            }
+        }
+        else if (method === 'GET' && payloadStr) {
+            try {
+                const queryParams = JSON.parse(payloadStr);
+                for (const [key, value] of Object.entries(queryParams)) {
+                    urlObj.searchParams.append(key, String(value));
+                }
+            }
+            catch (e) {
+                return resolve(`❌ Error: payload_json must be a valid JSON string representing query params. Parse error: ${e.message}`);
+            }
+        }
+        const req = https.request(urlObj, options, (res) => {
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => {
+                let formattedResult = `**HTTP Status:** \`${res.statusCode} ${res.statusMessage}\`\n`;
+                formattedResult += `**Content-Type:** \`${res.headers['content-type']}\`\n\n`;
+                try {
+                    const parsed = JSON.parse(data);
+                    // Highlight Validation Errors (The main goal of the probe)
+                    if (res.statusCode === 400 || res.statusCode === 422 || parsed.fieldErrors || parsed.error) {
+                        formattedResult += `### 🚨 Validation Error Detected (Jackpot!)\n`;
+                        formattedResult += `\`\`\`json\n${JSON.stringify(parsed, null, 2)}\n\`\`\``;
+                    }
+                    else {
+                        formattedResult += `### Response Body\n`;
+                        formattedResult += `\`\`\`json\n${JSON.stringify(parsed, null, 2).substring(0, 2000)}${data.length > 2000 ? '\n... (truncated)' : ''}\n\`\`\``;
+                    }
+                }
+                catch (e) {
+                    // Not JSON
+                    formattedResult += `### Raw Response Body\n`;
+                    formattedResult += `\`\`\`text\n${data.substring(0, 2000)}${data.length > 2000 ? '\n... (truncated)' : ''}\n\`\`\``;
+                }
+                resolve(formattedResult);
+            });
+        });
+        req.on('error', (e) => resolve(`❌ Request Error: ${e.message}`));
+        if (postData)
+            req.write(postData);
+        req.end();
+    });
+}
+export const polliBetaDiscoveryTool = tool({
+    description: `Explore the Pollinations API using Hybrid Discovery (OpenAPI + Active Probing).
+Use this tool ONLY to reverse engineer and fill the manual registry. Do not use this tool lightly for general operations.
+
+🔥 CRITICAL RULES FOR AI AGENTS:
+1. The EXACT and ONLY base URL for any generative media endpoints (image, video, audio) is: **https://gen.pollinations.ai**
+2. The URL 'enter.pollinations.ai' is strictly reserved for the OpenAPI schema documentation and account management. Do NOT hallucinate target endpoints on it!
+
+Commands available:
+- 'list_endpoints': (Whitebox) Returns all routes from OpenAPI.
+- 'get_endpoint': (Whitebox) Returns param schema for a route from OpenAPI.
+- 'get_enums': (Whitebox) Recursively searches the OpenAPI spec for a parameter enum (e.g. 'voice', 'model').
+- 'probe_endpoint': (Blackbox) Sends a real HTTP request (GET or POST) to trigger API validation errors (HTTP 400). Use this to reverse-engineer undocumented enums by sending invalid values. The tool auto-injects your API key.`,
+    args: {
+        command: tool.schema.enum(['list_endpoints', 'get_endpoint', 'get_enums', 'probe_endpoint']).describe('The action to perform'),
+        endpoint_path: tool.schema.string().optional().describe('OpenAPI path (e.g. "/v1/chat/completions") or full URL for probe_endpoint'),
+        parameter_name: tool.schema.string().optional().describe('Required for get_enums (e.g. "voice", "model")'),
+        probe_method: tool.schema.enum(['GET', 'POST']).optional().describe('Required for probe_endpoint'),
+        probe_payload_json: tool.schema.string().optional().describe('JSON string of query params (GET) or body (POST) to send during probe_endpoint. e.g. "{\\"model\\":\\"fake-model\\"}" to trigger an error showing valid models.'),
+    },
+    async execute(args, context) {
+        emitStatusToast('info', `Discovery: ${args.command}...`, '🔎 API Probe');
+        context.metadata({ title: `Probe: ${args.command}` });
+        try {
+            if (args.command === 'probe_endpoint') {
+                if (!args.endpoint_path || !args.probe_method) {
+                    return '❌ Error: `endpoint_path` and `probe_method` are required for command `probe_endpoint`';
+                }
+                return await probeEndpoint(args.probe_method, args.endpoint_path, args.probe_payload_json);
+            }
+            // Whitebox commands need OpenAPI
+            const schema = await fetchOpenApiSchema();
+            if (args.command === 'list_endpoints') {
+                const paths = Object.keys(schema.paths || {});
+                return `**Available API Endpoints (OpenAPI):**\n\n\`\`\`json\n${JSON.stringify(paths, null, 2)}\n\`\`\``;
+            }
+            if (args.command === 'get_endpoint') {
+                if (!args.endpoint_path)
+                    return '❌ Error: `endpoint_path` is required';
+                const details = schema.paths[args.endpoint_path];
+                if (!details)
+                    return `❌ Endpoint '${args.endpoint_path}' not found in OpenAPI schema.`;
+                return `**Endpoint Details for \`${args.endpoint_path}\`:**\n\n\`\`\`json\n${JSON.stringify(details, null, 2)}\n\`\`\``;
+            }
+            if (args.command === 'get_enums') {
+                if (!args.parameter_name)
+                    return '❌ Error: `parameter_name` is required';
+                const results = [];
+                const findEnums = (obj, path = '') => {
+                    if (typeof obj !== 'object' || obj === null)
+                        return;
+                    if (obj.enum && Array.isArray(obj.enum) && path.includes(args.parameter_name)) {
+                        results.push({
+                            path: path,
+                            enum: obj.enum,
+                            description: obj.description
+                        });
+                    }
+                    for (const [key, value] of Object.entries(obj)) {
+                        findEnums(value, path ? `${path}.${key}` : key);
+                    }
+                };
+                findEnums(schema.components?.schemas, 'components.schemas');
+                findEnums(schema.paths, 'paths');
+                if (results.length === 0) {
+                    return `ℹ️ No enums found matching parameter '${args.parameter_name}' in OpenAPI. You should use 'probe_endpoint' to test it manually!`;
+                }
+                let output = `**Discovered Enums for '${args.parameter_name}':**\n\n`;
+                results.forEach(res => {
+                    output += `- **Found at**: \`${res.path}\`\n`;
+                    if (res.description)
+                        output += `  - **Desc**: ${res.description}\n`;
+                    output += `  - **Values**: ${res.enum.join(', ')}\n\n`;
+                });
+                return output;
+            }
+            return '❌ Unknown command';
+        }
+        catch (err) {
+            emitStatusToast('error', `Discovery failed: ${err.message}`, '🔎 API Probe');
+            return `❌ Critical Error: ${err.message}`;
+        }
+    }
+});