opencode-pollinations-plugin 6.4.6 → 6.4.8

package/dist/tools/pollinations/imgtools/clients.d.ts

@@ -0,0 +1,11 @@
+export interface ToolInput {
+    data: Buffer;
+    contentType: string;
+    filename: string;
+    options?: Record<string, string | number>;
+}
+export interface ToolResult {
+    imageUrl: string;
+    downloadUrls: string[];
+}
+export declare function processTool(toolName: string, input: ToolInput): Promise<ToolResult>;

package/dist/tools/pollinations/imgtools/clients.js

@@ -0,0 +1,182 @@
+// imgtools/clients.ts — orchestration upload → poll → download pour les 4 outils
+// Adapté depuis /home/fkomp/Bureau/oracle/dev-serveur/iamges-tools-api/modules/clients.js
+// Mode standalone : appels directs depuis l'IP utilisateur, pas de queue, pas d'API
+import { TOOLS, UA } from './config.js';
+import { getKey, encrypt, decrypt } from './crypto.js';
+import { buildMultipart, httpsPost, getDims, aspectRatio } from './helpers.js';
+const BASE_HEADERS = {
+    'User-Agent': UA,
+    'Accept': '*/*',
+    'Accept-Language': 'en-US,en;q=0.9',
+};
+function headersFor(t, contentType) {
+    return {
+        ...BASE_HEADERS,
+        'Origin': `https://${t.host}`,
+        'Referer': t.page,
+        ...(contentType ? { 'Content-Type': contentType } : {}),
+    };
+}
+function normalizeUrls(dUrls) {
+    if (Array.isArray(dUrls))
+        return dUrls.filter(u => u && String(u).trim()).map(u => String(u).trim());
+    if (dUrls && typeof dUrls === 'object') {
+        return Object.values(dUrls).filter(u => u && String(u).trim()).map(u => String(u).trim());
+    }
+    return [];
+}
+function hasUrls(dUrls) {
+    return normalizeUrls(dUrls).length > 0;
+}
+function resolveUrls(t, urls) {
+    const resolved = urls.map(u => {
+        if (String(u).startsWith('http'))
+            return String(u);
+        if (t.resultBase) {
+            const fn = String(u).split('/').pop() || '';
+            return `${t.resultBase}/${fn}`;
+        }
+        return String(u);
+    });
+    return { imageUrl: resolved[0] || '', downloadUrls: resolved };
+}
+// ─── Legacy (rmbg, upscale) ──────────────────────────────────────────
+async function uploadLegacy(t, file) {
+    const mpFields = [
+        { name: 'file', value: file.data, filename: file.filename || 'image.jpg', contentType: file.contentType || 'image/jpeg' },
+    ];
+    if (t.uploadFields) {
+        for (const [k, v] of Object.entries(t.uploadFields)) {
+            let val = v;
+            if (k === 'ratio' && file.options?.ratio)
+                val = String(file.options.ratio);
+            mpFields.push({ name: k, value: val });
+        }
+    }
+    const { boundary, body } = buildMultipart(mpFields);
+    const hdrs = headersFor(t, `multipart/form-data; boundary=${boundary}`);
+    const res = await httpsPost(t.host, t.uploadPath, hdrs, body);
+    if (res.status !== 200)
+        throw new Error(`Upload ${t.name} failed: ${res.status} ${res.body.toString('utf8').slice(0, 200)}`);
+    let json;
+    try {
+        json = JSON.parse(res.body.toString('utf8'));
+    }
+    catch {
+        throw new Error(`Upload ${t.name} non-JSON: ${res.body.toString('utf8').slice(0, 200)}`);
+    }
+    if (json.downloadUrls && hasUrls(json.downloadUrls)) {
+        return { code: null, directUrls: normalizeUrls(json.downloadUrls) };
+    }
+    const code = json.code || json.taskId || json.taskCode || (json.data && (json.data.code || json.data.taskId));
+    if (!code)
+        throw new Error(`Upload ${t.name}: no code in ${JSON.stringify(json).slice(0, 300)}`);
+    return { code: String(code), directUrls: [] };
+}
+async function pollLegacy(t, code) {
+    const codes = Array.isArray(code) ? code : [code];
+    const bodyObj = t.statusBodyBuilder ? t.statusBodyBuilder(codes) : { type: t.statusType, [t.statusField]: codes };
+    const body = JSON.stringify(bodyObj);
+    const hdrs = headersFor(t, 'application/json');
+    const res = await httpsPost(t.host, t.statusPath, hdrs, body);
+    if (res.status !== 200)
+        throw new Error(`Status ${t.name} failed: ${res.status}`);
+    try {
+        return JSON.parse(res.body.toString('utf8'));
+    }
+    catch {
+        throw new Error(`Status ${t.name} non-JSON`);
+    }
+}
+// ─── Encrypted (ruo, enhance) ────────────────────────────────────────
+function buildUploadParams(t, file, dims, extra) {
+    const ratio = aspectRatio(dims.width, dims.height);
+    if (t.name === 'ruo') {
+        const p = String(extra.prompt || 'remove unwanted objects');
+        return {
+            type: t.statusType, selected_model: t.selectedModel, model_name: t.modelName,
+            user_id: 'anonymous', tool: t.tool,
+            positive_prompts: p, resolved_prompt: p, raw_prompt: p,
+            aspect_ratio: ratio, prompt_image_refs: ['primary'], image_order_map: ['primary'],
+        };
+    }
+    if (t.name === 'enhance') {
+        const prompt = t.prompt;
+        const tls = Number(extra.targetLongestSide || 1024);
+        return {
+            positive_prompts: prompt, resolved_prompt: prompt, aspect_ratio: ratio,
+            selected_model: t.selectedModel, model_name: t.modelName,
+            user_id: 'anonymous', type: t.statusType, target_longest_side: tls,
+        };
+    }
+    throw new Error(`Unknown encrypted tool: ${t.name}`);
+}
+async function uploadEncrypted(t, file) {
+    const key = getKey(t.crypto.salt);
+    const dims = getDims(file.data) || { width: 0, height: 0 };
+    const params = buildUploadParams(t, file, dims, file.options || {});
+    const enc = encrypt(params, key);
+    const { boundary, body } = buildMultipart([
+        { name: 'params', value: enc },
+        { name: 'file', value: file.data, filename: file.filename || 'image.jpg', contentType: file.contentType || 'image/jpeg' },
+        { name: 'selected_model', value: t.selectedModel },
+    ]);
+    const hdrs = headersFor(t, `multipart/form-data; boundary=${boundary}`);
+    const res = await httpsPost(t.host, t.uploadPath, hdrs, body);
+    if (res.status !== 200)
+        throw new Error(`Upload ${t.name} failed: ${res.status}`);
+    const json = JSON.parse(res.body.toString('utf8'));
+    if (!json.data_enc)
+        throw new Error(`Upload ${t.name}: no data_enc in ${JSON.stringify(json).slice(0, 200)}`);
+    const dec = decrypt(json.data_enc, key);
+    if (!dec.code)
+        throw new Error(`Upload ${t.name}: no code in decrypted ${JSON.stringify(dec).slice(0, 200)}`);
+    return { code: String(dec.code) };
+}
+async function pollEncrypted(t, code) {
+    const key = getKey(t.crypto.salt);
+    const statusPayload = { type: t.statusType, code, user_id: 'anonymous' };
+    const enc = encrypt(statusPayload, key);
+    const body = JSON.stringify({ params: enc });
+    const hdrs = headersFor(t, 'application/json');
+    const res = await httpsPost(t.host, t.statusPath, hdrs, body);
+    if (res.status !== 200)
+        throw new Error(`Status ${t.name} failed: ${res.status}`);
+    const json = JSON.parse(res.body.toString('utf8'));
+    if (!json.data_enc)
+        throw new Error(`Status ${t.name}: no data_enc`);
+    return decrypt(json.data_enc, key);
+}
+// ─── Orchestrateur principal ─────────────────────────────────────────
+export async function processTool(toolName, input) {
+    const t = TOOLS[toolName];
+    if (!t)
+        throw new Error(`Unknown tool: ${toolName}`);
+    const isEncrypted = !!t.crypto;
+    const upRes = isEncrypted
+        ? await uploadEncrypted(t, input)
+        : await uploadLegacy(t, input);
+    if ('directUrls' in upRes && upRes.directUrls && upRes.directUrls.length > 0) {
+        return resolveUrls(t, upRes.directUrls);
+    }
+    const code = 'code' in upRes ? upRes.code : upRes.code;
+    let status;
+    for (let i = 0; i < t.maxPolls; i++) {
+        if (i > 0)
+            await new Promise(r => setTimeout(r, t.pollInterval));
+        status = isEncrypted
+            ? await pollEncrypted(t, code)
+            : await pollLegacy(t, code);
+        if (status.status === 'success' || hasUrls(status.downloadUrls))
+            break;
+        if (status.status === 'failed')
+            throw new Error(`Status ${t.name} failed: ${status.message || JSON.stringify(status).slice(0, 200)}`);
+        if (status.status && !['processing', 'pending', 'queued', 'waiting'].includes(status.status)) {
+            throw new Error(`Status ${t.name} unexpected: ${JSON.stringify(status).slice(0, 300)}`);
+        }
+    }
+    const urls = status ? normalizeUrls(status.downloadUrls) : [];
+    if (!urls.length)
+        throw new Error(`Polling ${t.name} timeout: no downloadUrls after ${t.maxPolls} attempts`);
+    return resolveUrls(t, urls);
+}

package/dist/tools/pollinations/imgtools/config.d.ts

@@ -0,0 +1,42 @@
+export declare const UA = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) HeadlessChrome/150.0.0.0 Safari/537.36";
+export declare const CRYPTO: {
+    PBKDF2: {
+        iterations: number;
+        hash: string;
+        keylen: number;
+    };
+    AES_GCM: {
+        ivLen: number;
+        tagLen: number;
+    };
+    password: string;
+};
+export interface ToolConfig {
+    name: string;
+    label: string;
+    host: string;
+    uploadPath: string;
+    statusPath: string;
+    crypto: typeof CRYPTO & {
+        salt: string;
+    } | null;
+    statusType: number;
+    statusField: string;
+    maxPolls: number;
+    pollInterval: number;
+    downloadUrlsFormat?: string;
+    page: string;
+    uploadFields?: Record<string, string>;
+    statusBodyBuilder?: (codes: string[]) => Record<string, unknown>;
+    selectedModel?: string;
+    modelName?: string;
+    tool?: string;
+    resultBase?: string;
+    ratios?: string[];
+    targetLongestSides?: Array<{
+        label: string;
+        value: number;
+    }>;
+    prompt?: string;
+}
+export declare const TOOLS: Record<string, ToolConfig>;

package/dist/tools/pollinations/imgtools/config.js

@@ -0,0 +1,81 @@
+// imgtools/config.ts — endpoints, crypto params, headers des 4 outils
+// Adapté depuis /home/fkomp/Bureau/oracle/dev-serveur/iamges-tools-api/modules/config.js
+export const UA = 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) HeadlessChrome/150.0.0.0 Safari/537.36';
+export const CRYPTO = {
+    PBKDF2: { iterations: 10000, hash: 'sha256', keylen: 32 },
+    AES_GCM: { ivLen: 12, tagLen: 16 },
+    password: 'vH33r_2025_AES_GCM_S3cur3_K3y_9X7mP4qR8nT2wE5yU1oI6aS3dF7gH0jK9lZ',
+};
+export const TOOLS = {
+    rmbg: {
+        name: 'rmbg',
+        label: 'Background Removal',
+        host: 'bgeraser.com',
+        uploadPath: '/api/bgeraser/legacy/upload',
+        statusPath: '/api/bgeraser/legacy/status',
+        crypto: null,
+        statusType: 4,
+        statusField: 'codes',
+        uploadFields: { type: '4', mattValue: '0' },
+        maxPolls: 30,
+        pollInterval: 5000,
+        downloadUrlsFormat: 'object',
+        page: 'https://bgeraser.com',
+    },
+    ruo: {
+        name: 'ruo',
+        label: 'Remove Unwanted Objects',
+        host: 'objectremover.com',
+        uploadPath: '/api/u2/upload',
+        statusPath: '/api/u2/status',
+        crypto: { ...CRYPTO, salt: 'objectremover-salt-2026' },
+        statusType: 7,
+        statusField: 'code',
+        maxPolls: 40,
+        pollInterval: 3000,
+        selectedModel: 'flux_klein/edit',
+        modelName: 'Flux Klein Edit',
+        tool: 'object-remover',
+        page: 'https://objectremover.com',
+        resultBase: 'https://access.vheer.com/results',
+    },
+    upscale: {
+        name: 'upscale',
+        label: 'Image Upscaler',
+        host: 'imgupscaler.com',
+        uploadPath: '/api/legacy/upload',
+        statusPath: '/api/legacy/status',
+        crypto: null,
+        statusType: 4,
+        statusField: 'codes',
+        statusBodyBuilder: (codes) => ({ taskId: codes[0] }),
+        uploadFields: { type: '4' },
+        maxPolls: 30,
+        pollInterval: 5000,
+        downloadUrlsFormat: 'array',
+        page: 'https://imgupscaler.com',
+        ratios: ['200', '400'],
+    },
+    enhance: {
+        name: 'enhance',
+        label: 'AI Image Enhancer',
+        host: 'imgupscaler.com',
+        uploadPath: '/api/u2/upload',
+        statusPath: '/api/u2/status',
+        crypto: { ...CRYPTO, salt: 'imgupscaler-salt-2026' },
+        statusType: 7,
+        statusField: 'code',
+        maxPolls: 40,
+        pollInterval: 3000,
+        selectedModel: 'hypir',
+        modelName: 'Hypir Enhancer',
+        page: 'https://imgupscaler.com/enhancer',
+        resultBase: 'https://access.vheer.com/results',
+        prompt: 'preserve facial identity, preserve facial geometry, restore image clarity, enhance natural details, reduce blur and noise, preserve original colors and structure',
+        targetLongestSides: [
+            { label: '1K', value: 1024 },
+            { label: '2K', value: 2048 },
+            { label: '4K', value: 4096 },
+        ],
+    },
+};

package/dist/tools/pollinations/imgtools/crypto.d.ts

@@ -0,0 +1,4 @@
+export declare function deriveKey(password: string, salt: string): Buffer;
+export declare function encrypt(data: Record<string, unknown>, key: Buffer): string;
+export declare function decrypt(encoded: string, key: Buffer): any;
+export declare function getKey(salt: string): Buffer;

package/dist/tools/pollinations/imgtools/crypto.js

@@ -0,0 +1,34 @@
+// imgtools/crypto.ts — AES-GCM + PBKDF2 pour ruo/enhance
+// Adapté depuis /home/fkomp/Bureau/oracle/dev-serveur/iamges-tools-api/modules/crypto.js
+import * as crypto from 'crypto';
+const PBKDF2 = { iterations: 10000, hash: 'sha256', keylen: 32 };
+const AES_GCM = { ivLen: 12, tagLen: 16 };
+export function deriveKey(password, salt) {
+    return crypto.pbkdf2Sync(Buffer.from(password, 'utf8'), Buffer.from(salt, 'utf8'), PBKDF2.iterations, PBKDF2.keylen, PBKDF2.hash);
+}
+export function encrypt(data, key) {
+    const iv = crypto.randomBytes(AES_GCM.ivLen);
+    const plaintext = Buffer.from(JSON.stringify(data), 'utf8');
+    const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+    const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return Buffer.concat([iv, ciphertext, tag]).toString('base64');
+}
+export function decrypt(encoded, key) {
+    const buf = Buffer.from(encoded, 'base64');
+    const iv = buf.subarray(0, 12);
+    const ciphertext = buf.subarray(12, -16);
+    const tag = buf.subarray(-16);
+    const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
+    decipher.setAuthTag(tag);
+    const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+    return JSON.parse(plaintext.toString('utf8'));
+}
+const _keyCache = {};
+export function getKey(salt) {
+    if (_keyCache[salt])
+        return _keyCache[salt];
+    const key = deriveKey('vH33r_2025_AES_GCM_S3cur3_K3y_9X7mP4qR8nT2wE5yU1oI6aS3dF7gH0jK9lZ', salt);
+    _keyCache[salt] = key;
+    return key;
+}

package/dist/tools/pollinations/imgtools/helpers.d.ts

@@ -0,0 +1,24 @@
+export declare function sleep(ms: number): Promise<void>;
+export declare function buildMultipart(fields: Array<{
+    name: string;
+    value: Buffer | string;
+    filename?: string;
+    contentType?: string;
+}>): {
+    boundary: string;
+    body: Buffer;
+};
+export declare function httpsPost(host: string, path: string, headers: Record<string, string>, body: Buffer | string): Promise<{
+    status: number;
+    body: Buffer;
+    headers: Record<string, string>;
+}>;
+export declare function getDims(buf: Buffer): {
+    width: number;
+    height: number;
+} | null;
+export declare function aspectRatio(w: number, h: number): string;
+export declare function dlImage(url: string): Promise<{
+    body: Buffer;
+    contentType: string;
+}>;

package/dist/tools/pollinations/imgtools/helpers.js

@@ -0,0 +1,111 @@
+// imgtools/helpers.ts — HTTP, multipart, image dimensions
+// Adapté depuis /home/fkomp/Bureau/oracle/dev-serveur/iamges-tools-api/modules/helpers.js
+import * as https from 'https';
+import * as crypto from 'crypto';
+export function sleep(ms) {
+    return new Promise(r => setTimeout(r, ms));
+}
+export function buildMultipart(fields) {
+    const boundary = '----WebKitFormBoundary' + crypto.randomBytes(16).toString('hex');
+    const parts = [];
+    for (const f of fields) {
+        let h = `--${boundary}\r\nContent-Disposition: form-data; name="${f.name}"`;
+        if (f.filename) {
+            h += `; filename="${f.filename}"\r\nContent-Type: ${f.contentType || 'application/octet-stream'}\r\n\r\n`;
+            parts.push(Buffer.from(h));
+            parts.push(typeof f.value === 'string' ? Buffer.from(f.value) : f.value);
+            parts.push(Buffer.from('\r\n'));
+        }
+        else {
+            h += `\r\n\r\n${f.value}\r\n`;
+            parts.push(Buffer.from(h));
+        }
+    }
+    parts.push(Buffer.from(`--${boundary}--\r\n`));
+    return { boundary, body: Buffer.concat(parts) };
+}
+export function httpsPost(host, path, headers, body) {
+    return new Promise((resolve, reject) => {
+        const req = https.request({
+            hostname: host,
+            path,
+            method: 'POST',
+            headers: {
+                'Content-Length': Buffer.byteLength(body),
+                ...headers,
+            },
+            timeout: 120000,
+        }, (res) => {
+            const chunks = [];
+            res.on('data', c => chunks.push(c));
+            res.on('end', () => {
+                resolve({
+                    status: res.statusCode || 0,
+                    body: Buffer.concat(chunks),
+                    headers: res.headers,
+                });
+            });
+        });
+        req.on('error', reject);
+        req.on('timeout', () => { req.destroy(); reject(new Error('Timeout')); });
+        if (typeof body === 'string')
+            req.write(body);
+        else
+            req.write(body);
+        req.end();
+    });
+}
+export function getDims(buf) {
+    try {
+        // PNG
+        if (buf[0] === 0x89 && buf[1] === 0x50) {
+            return { width: buf.readUInt32BE(16), height: buf.readUInt32BE(20) };
+        }
+        // JPEG
+        if (buf[0] === 0xff && buf[1] === 0xd8) {
+            let offset = 2;
+            while (offset < buf.length) {
+                if (buf[offset] !== 0xff)
+                    break;
+                const marker = buf[offset + 1];
+                if (marker === 0xc0 || marker === 0xc2) {
+                    return { width: buf.readUInt16BE(offset + 7), height: buf.readUInt16BE(offset + 5) };
+                }
+                offset += 2 + buf.readUInt16BE(offset + 2);
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export function aspectRatio(w, h) {
+    if (w === 0 || h === 0)
+        return '1:1';
+    const r = w / h;
+    if (r > 1.7)
+        return '16:9';
+    if (r > 1.2)
+        return '4:3';
+    if (r > 0.8)
+        return '1:1';
+    if (r > 0.55)
+        return '3:4';
+    return '9:16';
+}
+export async function dlImage(url) {
+    return new Promise((resolve, reject) => {
+        https.get(url, { timeout: 15000 }, (res) => {
+            if (res.statusCode && res.statusCode >= 400) {
+                return reject(new Error(`Download failed: ${res.statusCode}`));
+            }
+            const chunks = [];
+            res.on('data', c => chunks.push(c));
+            res.on('end', () => resolve({
+                body: Buffer.concat(chunks),
+                contentType: res.headers['content-type'] || 'image/png',
+            }));
+        }).on('error', reject);
+    });
+}

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

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

package/dist/tools/pollinations/object_remover.js

@@ -0,0 +1,62 @@
+// object_remover — Suppression d'objets par prompt via objectremover.com
+// Standalone : appel direct depuis l'IP utilisateur, pas d'API, pas de clé
+import { tool } from '@opencode-ai/plugin/tool';
+import * as fs from 'fs';
+import * as path from 'path';
+import { ensureDir, generateFilename, getDefaultOutputDir, formatFileSize, sanitizeFilename, httpsGet, } from './shared.js';
+import { emitStatusToast } from '../../server/toast.js';
+import { t } from '../../locales/index.js';
+import { processTool } from './imgtools/clients.js';
+export const objectRemoverTool = tool({
+    description: `Supprime un objet d'une image via un prompt (gratuit, appel direct). 
+Exemples : "remove the person", "erase the text", "delete the car". 
+Temps de traitement : 30-120s. Pas de clé requise.`,
+    args: {
+        file: tool.schema.string().describe('Chemin local de l\'image à traiter'),
+        prompt: tool.schema.string().describe('Description de l\'objet à supprimer (ex: "remove the red car")'),
+        save_to: tool.schema.string().optional().describe('Dossier de sortie'),
+        filename: tool.schema.string().optional().describe('Nom du fichier de sortie (sans extension)'),
+    },
+    async execute(args, context) {
+        const imagePath = args.file;
+        if (!fs.existsSync(imagePath)) {
+            return t('tools.object_remover.file_not_found', { path: imagePath }) || `❌ Fichier introuvable : ${imagePath}`;
+        }
+        const ext = path.extname(imagePath).toLowerCase();
+        const mimeType = ext === '.png' ? 'image/png' : 'image/jpeg';
+        const imageData = fs.readFileSync(imagePath);
+        const prompt = args.prompt || 'remove unwanted objects';
+        context.metadata({ title: '🧹 object_remover', metadata: { type: 'info', message: `Suppression de "${prompt}"...` } });
+        try {
+            const result = await processTool('ruo', {
+                data: imageData,
+                contentType: mimeType,
+                filename: path.basename(imagePath),
+                options: { prompt },
+            });
+            if (!result.imageUrl) {
+                return t('tools.object_remover.no_result') || '❌ Aucun résultat reçu.';
+            }
+            const dl = await httpsGet(result.imageUrl);
+            const outputDir = args.save_to ? args.save_to : getDefaultOutputDir('object_remover');
+            const outputFilename = (args.filename ? sanitizeFilename(args.filename) : generateFilename('ruo', 'object-remover', 'png'));
+            const filePath = path.join(outputDir, outputFilename.includes('.') ? outputFilename : `${outputFilename}.png`);
+            ensureDir(outputDir);
+            fs.writeFileSync(filePath, dl.data);
+            emitStatusToast("success", "🧹 Objet supprimé", "object_remover", { filePath, freeTool: true });
+            emitStatusToast('success', '🧹 Objet supprimé', 'object_remover', { filePath, freeTool: true });
+            const fileSize = fs.statSync(filePath).size;
+            const lines = [];
+            lines.push('🧹 **Objet Supprimé**');
+            lines.push('━━━━━━━━━━━━━━━━━━');
+            lines.push(`Fichier : \`${filePath}\``);
+            lines.push(`Taille  : ${formatFileSize(fileSize)}`);
+            lines.push(`Prompt  : ${prompt}`);
+            return lines.join('\n');
+        }
+        catch (err) {
+            emitStatusToast("warning", "❌ " + (err.message?.substring(0, 80) || ""), "object_remover", { freeTool: true });
+            return "❌ Erreur : " + err.message;
+        }
+    },
+});