opencode-pollinations-plugin 6.1.0-beta.2 → 6.1.0-beta.22

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

@@ -0,0 +1,13 @@
+/**
+ * transcribe_audio Tool - Pollinations Speech-to-Text (STT)
+ *
+ * Updated: 2026-02-12 - Verified API Reference
+ *
+ * 1. whisper-large-v3 (DEFAULT): High accuracy Whisper model
+ * 2. whisper-1: Standard Whisper model
+ * 3. scribe: ElevenLabs Scribe v2
+ *
+ * All models use /v1/audio/transcriptions (POST multipart)
+ */
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const polliSttTool: ToolDefinition;

package/dist/tools/pollinations/transcribe_audio.js

@@ -0,0 +1,194 @@
+/**
+ * transcribe_audio Tool - Pollinations Speech-to-Text (STT)
+ *
+ * Updated: 2026-02-12 - Verified API Reference
+ *
+ * 1. whisper-large-v3 (DEFAULT): High accuracy Whisper model
+ * 2. whisper-1: Standard Whisper model
+ * 3. scribe: ElevenLabs Scribe v2
+ *
+ * All models use /v1/audio/transcriptions (POST multipart)
+ */
+import { tool } from '@opencode-ai/plugin/tool';
+import * as fs from 'fs';
+import * as path from 'path';
+import { getApiKey, httpsPostMultipart, ensureDir, formatFileSize, getAudioModels, } from './shared.js';
+// ─── Constants ─────────────────────────────────────────────────────────────
+const DEFAULT_MODEL = 'whisper-large-v3';
+const SUPPORTED_FORMATS = ['mp3', 'wav', 'm4a', 'webm', 'mp4', 'mpeg', 'mpga', 'ogg'];
+// ─── Tool Definition ──────────────────────────────────────────────────────
+export const polliSttTool = tool({
+    description: `Transcribe audio to text using Pollinations AI.
+
+**🎙️ Models:**
+
+| Model | Supplier | Notes |
+|-------|----------|-------|
+| whisper-large-v3 | OpenAI | **DEFAULT** - High accuracy, long audio |
+| whisper-1 | OpenAI | Standard accuracy |
+| scribe | ElevenLabs | Scribe v2 model |
+
+**📁 Supported Formats:**
+mp3, wav, m4a, webm, mp4, mpeg, mpga, ogg
+
+**💡 Tips:**
+- Use \`whisper-large-v3\` for the highest accuracy on long recordings
+- Supports both local files and URLs
+
+**📋 Output:**
+- Returns transcribed text
+- Includes detected language (if available)
+- Shows processing time`,
+    args: {
+        file: tool.schema.string().describe('Path to audio file or URL to transcribe'),
+        model: tool.schema.string().optional().describe(`STT model (default: ${DEFAULT_MODEL})`),
+        language: tool.schema.string().optional().describe('Language hint (e.g., "en", "fr", "es")'),
+        save_transcript: tool.schema.boolean().optional().describe('Save transcript to file (default: false)'),
+    },
+    async execute(args, context) {
+        const apiKey = getApiKey();
+        if (!apiKey) {
+            return `❌ La transcription nécessite une clé API Pollinations.
+🔧 Connectez votre clé avec /pollinations connect`;
+        }
+        const model = args.model || DEFAULT_MODEL;
+        // Validate model
+        const audioModels = getAudioModels();
+        const modelInfo = audioModels[model];
+        if (!modelInfo || (modelInfo.type !== 'stt' && modelInfo.type !== 'both')) {
+            return `❌ Modèle STT inconnu: ${model}
+💡 Modèles STT disponibles: ${Object.entries(audioModels)
+                .filter(([, info]) => info.type === 'stt' || info.type === 'both')
+                .map(([name]) => name)
+                .join(', ')}`;
+        }
+        // Check file
+        let audioPath = args.file;
+        let audioBuffer;
+        let fileName = 'audio.mp3';
+        if (audioPath.startsWith('http://') || audioPath.startsWith('https://')) {
+            // Download from URL
+            context.metadata({ title: `🎙️ STT: Downloading...` });
+            try {
+                const https = await import('https');
+                const http = await import('http');
+                const protocol = audioPath.startsWith('https') ? https : http;
+                audioBuffer = await new Promise((resolve, reject) => {
+                    const chunks = [];
+                    protocol.get(audioPath, (res) => {
+                        if (res.statusCode === 301 || res.statusCode === 302) {
+                            // Follow redirect
+                            const redirectUrl = res.headers.location;
+                            if (redirectUrl) {
+                                const redirectProtocol = redirectUrl.startsWith('https') ? https : http;
+                                redirectProtocol.get(redirectUrl, (res2) => {
+                                    res2.on('data', chunk => chunks.push(chunk));
+                                    res2.on('end', () => resolve(Buffer.concat(chunks)));
+                                    res2.on('error', reject);
+                                }).on('error', reject);
+                                return;
+                            }
+                        }
+                        res.on('data', chunk => chunks.push(chunk));
+                        res.on('end', () => resolve(Buffer.concat(chunks)));
+                        res.on('error', reject);
+                    }).on('error', reject);
+                });
+                // Extract filename from URL
+                try {
+                    const urlPath = new URL(audioPath).pathname;
+                    fileName = path.basename(urlPath) || 'audio.mp3';
+                }
+                catch {
+                    fileName = 'audio.mp3';
+                }
+            }
+            catch (err) {
+                return `❌ Impossible de télécharger l'audio: ${err.message}`;
+            }
+        }
+        else {
+            // Local file
+            if (!fs.existsSync(audioPath)) {
+                return `❌ Fichier non trouvé: ${audioPath}`;
+            }
+            // Check format
+            const ext = path.extname(audioPath).toLowerCase().replace('.', '');
+            if (!SUPPORTED_FORMATS.includes(ext)) {
+                return `⚠️ Format non supporté: .${ext}
+💡 Formats supportés: ${SUPPORTED_FORMATS.join(', ')}`;
+            }
+            audioBuffer = fs.readFileSync(audioPath);
+            fileName = path.basename(audioPath);
+        }
+        const fileSize = audioBuffer.length;
+        // Metadata
+        context.metadata({ title: `🎙️ STT: ${model} (${formatFileSize(fileSize)})` });
+        try {
+            let transcript = '';
+            let detectedLanguage = '';
+            // === All STT models use multipart endpoint ===
+            const fields = {
+                file: audioBuffer,
+                model: model,
+            };
+            if (args.language) {
+                fields.language = args.language;
+            }
+            const response = await httpsPostMultipart('https://gen.pollinations.ai/v1/audio/transcriptions', fields, {
+                'Authorization': `Bearer ${apiKey}`,
+            });
+            const data = JSON.parse(response.data.toString());
+            transcript = data.text || '';
+            detectedLanguage = data.language || '';
+            if (!transcript) {
+                return `❌ Aucune transcription générée.
+💡 Vérifiez que l'audio contient de la parole claire.`;
+            }
+            // Build result
+            const lines = [
+                `🎙️ Transcription Audio`,
+                `━━━━━━━━━━━━━━━━━━`,
+                `Fichier: ${fileName}`,
+                `Taille: ${formatFileSize(fileSize)}`,
+                `Modèle: ${model}`,
+            ];
+            if (detectedLanguage) {
+                lines.push(`Langue détectée: ${detectedLanguage}`);
+            }
+            if (args.language) {
+                lines.push(`Langue demandée: ${args.language}`);
+            }
+            lines.push(``);
+            lines.push(`📝 **Transcription:**`);
+            lines.push(``);
+            lines.push(transcript);
+            // Save transcript if requested
+            if (args.save_transcript) {
+                const outputDir = process.env.HOME
+                    ? path.join(process.env.HOME, 'Downloads', 'pollinations', 'transcripts')
+                    : '/tmp';
+                ensureDir(outputDir);
+                const baseName = path.basename(fileName, path.extname(fileName));
+                const outputPath = path.join(outputDir, `${baseName}_transcript.txt`);
+                fs.writeFileSync(outputPath, transcript);
+                lines.push(``);
+                lines.push(`💾 Transcription sauvegardée: ${outputPath}`);
+            }
+            return lines.join('\n');
+        }
+        catch (err) {
+            if (err.message?.includes('402') || err.message?.includes('Payment')) {
+                return `❌ Crédits insuffisants.`;
+            }
+            if (err.message?.includes('401') || err.message?.includes('403')) {
+                return `❌ Clé API invalide ou non autorisée.`;
+            }
+            if (err.message?.includes('413') || err.message?.includes('too large')) {
+                return `❌ Fichier audio trop volumineux.
+💡 Essayez de compresser ou découper l'audio.`;
+            }
+            return `❌ Erreur transcription: ${err.message}`;
+        }
+    },
+});

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

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

package/dist/tools/power/extract_audio.js

@@ -0,0 +1,179 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import * as https from 'https';
+import * as http from 'http';
+import { resolveOutputDir, formatFileSize, safeName, formatTimestamp, TOOL_DIRS } from '../shared.js';
+import { hasSystemFFmpeg, getFFmpegInstallInstructions, runFFmpeg, runFFprobe } from '../ffmpeg.js';
+// ─── Download helper ────────────────────────────────────────────────────────
+function downloadFile(url) {
+    return new Promise((resolve, reject) => {
+        const ext = path.extname(new URL(url).pathname) || '.mp4';
+        const tempPath = path.join(os.tmpdir(), `video_${Date.now()}${ext}`);
+        const proto = url.startsWith('https') ? https : http;
+        const req = proto.get(url, { headers: { 'User-Agent': 'Mozilla/5.0 (compatible; OpenCode-Plugin/6.0)' } }, (res) => {
+            if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                return downloadFile(res.headers.location).then(resolve).catch(reject);
+            }
+            if (res.statusCode && res.statusCode >= 400) {
+                return reject(new Error(`HTTP ${res.statusCode}`));
+            }
+            const ws = fs.createWriteStream(tempPath);
+            res.pipe(ws);
+            ws.on('finish', () => { ws.close(); resolve(tempPath); });
+            ws.on('error', reject);
+        });
+        req.on('error', reject);
+        req.setTimeout(120000, () => { req.destroy(); reject(new Error('Timeout (120s)')); });
+    });
+}
+// ─── Tool Definition ────────────────────────────────────────────────────────
+export const extractAudioTool = tool({
+    description: `Extract the audio track from a video file or URL.
+Outputs MP3, WAV, AAC, or FLAC format.
+Can optionally extract only a time range (start/end).
+Requires system ffmpeg installed.
+Free to use — no API key needed.`,
+    args: {
+        source: tool.schema.string().describe('Video file path (absolute) or URL'),
+        format: tool.schema.enum(['mp3', 'wav', 'aac', 'flac']).optional()
+            .describe('Output audio format (default: mp3)'),
+        start: tool.schema.string().optional()
+            .describe('Start time to extract from (e.g. "00:00:10" or "10")'),
+        end: tool.schema.string().optional()
+            .describe('End time to extract to (e.g. "00:01:30" or "90")'),
+        filename: tool.schema.string().optional()
+            .describe('Custom output filename (without extension). Auto-generated if omitted'),
+        output_path: tool.schema.string().optional()
+            .describe('Custom output directory. Default: ~/Downloads/pollinations/audio/'),
+    },
+    async execute(args, context) {
+        if (!hasSystemFFmpeg()) {
+            return [
+                `❌ FFmpeg non trouvé!`,
+                ``,
+                `Cet outil nécessite ffmpeg :`,
+                getFFmpegInstallInstructions().split('\n').map(l => `  • ${l}`).join('\n')
+            ].join('\n');
+        }
+        // Resolve source
+        let videoPath;
+        let isRemote = false;
+        if (args.source.startsWith('http://') || args.source.startsWith('https://')) {
+            isRemote = true;
+            context.metadata({ title: `🎵 Téléchargement vidéo...` });
+            try {
+                videoPath = await downloadFile(args.source);
+            }
+            catch (err) {
+                return `❌ Erreur téléchargement: ${err.message}`;
+            }
+        }
+        else {
+            videoPath = args.source;
+            if (!fs.existsSync(videoPath)) {
+                return `❌ Fichier introuvable: ${videoPath}`;
+            }
+        }
+        // Check if video has audio
+        try {
+            // Using runFFprobe helper
+            const probe = runFFprobe([
+                '-v', 'quiet',
+                '-select_streams', 'a',
+                '-show_entries', 'stream=codec_type',
+                '-of', 'csv=p=0',
+                videoPath
+            ], { timeout: 10000 }).trim();
+            if (!probe) {
+                if (isRemote)
+                    try {
+                        fs.unlinkSync(videoPath);
+                    }
+                    catch { }
+                return `❌ Aucune piste audio détectée dans cette vidéo.`;
+            }
+        }
+        catch { }
+        const outputFormat = args.format || 'mp3';
+        const outputDir = resolveOutputDir(TOOL_DIRS.audio, args.output_path);
+        const baseName = args.filename
+            ? safeName(args.filename)
+            : safeName(path.basename(videoPath, path.extname(videoPath)));
+        const outputFile = path.join(outputDir, `${baseName}.${outputFormat}`);
+        try {
+            context.metadata({ title: `🎵 Extraction audio...` });
+            // Build ffmpeg args
+            const ffmpegArgs = ['-y', '-i', videoPath, '-vn'];
+            // Time range
+            if (args.start)
+                ffmpegArgs.push('-ss', args.start);
+            if (args.end)
+                ffmpegArgs.push('-to', args.end);
+            // Format-specific encoding
+            switch (outputFormat) {
+                case 'mp3':
+                    ffmpegArgs.push('-acodec', 'libmp3lame', '-q:a', '2');
+                    break;
+                case 'wav':
+                    ffmpegArgs.push('-acodec', 'pcm_s16le');
+                    break;
+                case 'aac':
+                    ffmpegArgs.push('-acodec', 'aac', '-b:a', '192k');
+                    break;
+                case 'flac':
+                    ffmpegArgs.push('-acodec', 'flac');
+                    break;
+            }
+            ffmpegArgs.push(outputFile);
+            runFFmpeg(ffmpegArgs, { timeout: 120000 });
+            // Cleanup
+            if (isRemote && fs.existsSync(videoPath)) {
+                try {
+                    fs.unlinkSync(videoPath);
+                }
+                catch { }
+            }
+            if (!fs.existsSync(outputFile)) {
+                return `❌ Extraction échouée — aucun fichier audio produit.`;
+            }
+            const stats = fs.statSync(outputFile);
+            // Get audio duration
+            let durationStr = 'N/A';
+            try {
+                const durRaw = runFFprobe([
+                    '-v', 'quiet',
+                    '-show_entries', 'format=duration',
+                    '-of', 'csv=p=0',
+                    outputFile
+                ], { timeout: 5000 }).trim();
+                const dur = parseFloat(durRaw);
+                if (!isNaN(dur))
+                    durationStr = formatTimestamp(dur);
+            }
+            catch { }
+            return [
+                `🎵 Audio Extrait`,
+                `━━━━━━━━━━━━━━━━━`,
+                `Source: ${isRemote ? args.source : path.basename(videoPath)}`,
+                `Format: ${outputFormat.toUpperCase()}`,
+                `Durée: ${durationStr}`,
+                `Fichier: ${outputFile}`,
+                `Taille: ${formatFileSize(stats.size)}`,
+                args.start || args.end ? `Plage: ${args.start || '0:00'} → ${args.end || 'fin'}` : '',
+                ``,
+                `Coût: Gratuit (ffmpeg local)`,
+            ].filter(Boolean).join('\n');
+        }
+        catch (err) {
+            if (isRemote && fs.existsSync(videoPath)) {
+                try {
+                    fs.unlinkSync(videoPath);
+                }
+                catch { }
+            }
+            return `❌ Erreur extraction audio: ${err.message}`;
+        }
+    },
+});

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

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

package/dist/tools/power/extract_frames.js

@@ -0,0 +1,237 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import * as https from 'https';
+import * as http from 'http';
+import { resolveOutputDir, formatFileSize, safeName, formatTimestamp, TOOL_DIRS } from '../shared.js';
+import { hasSystemFFmpeg, getFFmpegInstallInstructions, runFFmpeg, runFFprobe } from '../ffmpeg.js';
+function extractMetadata(videoPath) {
+    try {
+        // Use ffprobe JSON output for reliable parsing
+        const raw = runFFprobe([
+            '-v', 'quiet',
+            '-print_format', 'json',
+            '-show_format',
+            '-show_streams',
+            videoPath
+        ]);
+        const data = JSON.parse(raw);
+        const videoStream = data.streams?.find((s) => s.codec_type === 'video');
+        const audioStream = data.streams?.find((s) => s.codec_type === 'audio');
+        const format = data.format || {};
+        const duration = parseFloat(format.duration || videoStream?.duration || '0');
+        const fpsStr = videoStream?.r_frame_rate || '0/1';
+        const [fpsNum, fpsDen] = fpsStr.split('/').map(Number);
+        const fps = fpsDen ? Math.round((fpsNum / fpsDen) * 100) / 100 : 0;
+        const stats = fs.statSync(videoPath);
+        return {
+            duration,
+            durationStr: formatTimestamp(duration),
+            width: videoStream?.width || 0,
+            height: videoStream?.height || 0,
+            fps,
+            codec: videoStream?.codec_name || 'unknown',
+            bitrate: format.bit_rate ? `${Math.round(parseInt(format.bit_rate) / 1000)} kbps` : 'N/A',
+            fileSize: formatFileSize(stats.size),
+            hasAudio: !!audioStream,
+            audioCodec: audioStream?.codec_name,
+            audioSampleRate: audioStream?.sample_rate ? `${audioStream.sample_rate} Hz` : undefined,
+            audioChannels: audioStream?.channels,
+            format: format.format_name || path.extname(videoPath).slice(1),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function formatMetadataReport(meta, source) {
+    const lines = [
+        `📋 Métadonnées Vidéo`,
+        `━━━━━━━━━━━━━━━━━━━━`,
+        `Source: ${source}`,
+        `Durée: ${meta.durationStr} (${meta.duration.toFixed(2)}s)`,
+        `Résolution: ${meta.width}×${meta.height}`,
+        `FPS: ${meta.fps}`,
+        `Codec: ${meta.codec}`,
+        `Bitrate: ${meta.bitrate}`,
+        `Taille: ${meta.fileSize}`,
+        `Format: ${meta.format}`,
+    ];
+    if (meta.hasAudio) {
+        lines.push(`Audio: ${meta.audioCodec || 'oui'} (${meta.audioSampleRate || 'N/A'}, ${meta.audioChannels || '?'}ch)`);
+    }
+    else {
+        lines.push(`Audio: aucun`);
+    }
+    return lines.join('\n');
+}
+// ─── Video download ─────────────────────────────────────────────────────────
+function downloadVideo(url) {
+    return new Promise((resolve, reject) => {
+        const tempPath = path.join(os.tmpdir(), `video_${Date.now()}.mp4`);
+        const proto = url.startsWith('https') ? https : http;
+        const req = proto.get(url, { headers: { 'User-Agent': 'Mozilla/5.0 (compatible; OpenCode-Plugin/6.0)' } }, (res) => {
+            if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                return downloadVideo(res.headers.location).then(resolve).catch(reject);
+            }
+            if (res.statusCode && res.statusCode >= 400) {
+                return reject(new Error(`HTTP ${res.statusCode}`));
+            }
+            const ws = fs.createWriteStream(tempPath);
+            res.pipe(ws);
+            ws.on('finish', () => { ws.close(); resolve(tempPath); });
+            ws.on('error', reject);
+        });
+        req.on('error', reject);
+        req.setTimeout(120000, () => { req.destroy(); reject(new Error('Timeout téléchargement (120s)')); });
+    });
+}
+// ─── Frame extraction ───────────────────────────────────────────────────────
+function extractWithSystemFFmpeg(videoPath, outputDir, baseName, options) {
+    const outputs = [];
+    if (options.at_time) {
+        // Single Frame Extraction
+        const singleOutput = path.join(outputDir, `${baseName}_at_${options.at_time.replace(/:/g, '-')}.png`);
+        runFFmpeg([
+            '-y', '-i', videoPath,
+            '-ss', options.at_time,
+            '-frames:v', '1',
+            singleOutput
+        ], { timeout: 60000 });
+        if (fs.existsSync(singleOutput))
+            outputs.push(singleOutput);
+    }
+    else {
+        // Range Extraction
+        const fps = options.fps || 1;
+        const outputPattern = path.join(outputDir, `${baseName}_%03d.png`);
+        const args = ['-y', '-i', videoPath];
+        if (options.start)
+            args.push('-ss', options.start);
+        if (options.end)
+            args.push('-to', options.end);
+        args.push('-vf', `fps=${fps}`, outputPattern);
+        runFFmpeg(args, { timeout: 120000 });
+        fs.readdirSync(outputDir)
+            .filter(f => f.startsWith(baseName) && f.endsWith('.png'))
+            .sort()
+            .forEach(f => outputs.push(path.join(outputDir, f)));
+    }
+    return outputs;
+}
+// ─── Tool Definition ────────────────────────────────────────────────────────
+export const extractFramesTool = tool({
+    description: `Extract image frames from a video file or URL, and/or inspect video metadata.
+Can extract a single frame at a specific timestamp, or multiple frames from a time range.
+Set metadata_only=true to just get video info (duration, resolution, fps, codec, audio).
+Requires system ffmpeg (sudo apt install ffmpeg).
+Supports MP4, WebM, AVI, MKV, and other common formats.
+Free to use — no API key needed.`,
+    args: {
+        source: tool.schema.string().describe('Video file path (absolute) or URL'),
+        at_time: tool.schema.string().optional().describe('Extract single frame at timestamp (e.g. "00:00:05" or "5")'),
+        start: tool.schema.string().optional().describe('Start time for range extraction (e.g. "00:00:02")'),
+        end: tool.schema.string().optional().describe('End time for range extraction (e.g. "00:00:10")'),
+        fps: tool.schema.number().min(0.1).max(30).optional().describe('Frames per second for range extraction (default: 1)'),
+        filename: tool.schema.string().optional().describe('Base filename prefix. Auto-generated if omitted'),
+        output_path: tool.schema.string().optional().describe('Custom output directory (absolute or relative). Default: ~/Downloads/pollinations/frames/'),
+        metadata_only: tool.schema.boolean().optional().describe('If true, only return video metadata without extracting frames'),
+    },
+    async execute(args, context) {
+        // Check ffmpeg
+        if (!hasSystemFFmpeg()) {
+            return [
+                `❌ FFmpeg non trouvé!`,
+                ``,
+                `Cet outil nécessite ffmpeg. Installez-le :`,
+                getFFmpegInstallInstructions().split('\n').map(l => `  • ${l}`).join('\n')
+            ].join('\n');
+        }
+        // Resolve source: URL → download, path → validate
+        let videoPath;
+        let isRemote = false;
+        if (args.source.startsWith('http://') || args.source.startsWith('https://')) {
+            isRemote = true;
+            context.metadata({ title: `🎬 Téléchargement vidéo...` });
+            try {
+                videoPath = await downloadVideo(args.source);
+            }
+            catch (err) {
+                return `❌ Erreur téléchargement: ${err.message}`;
+            }
+        }
+        else {
+            videoPath = args.source;
+            if (!fs.existsSync(videoPath)) {
+                return `❌ Fichier introuvable: ${videoPath}`;
+            }
+        }
+        // ─── Metadata mode ─────────────────────────────────────────────
+        if (args.metadata_only) {
+            const meta = extractMetadata(videoPath);
+            if (isRemote && fs.existsSync(videoPath)) {
+                try {
+                    fs.unlinkSync(videoPath);
+                }
+                catch { }
+            }
+            if (!meta)
+                return `❌ Impossible de lire les métadonnées. Vérifiez que ffprobe est installé.`;
+            return formatMetadataReport(meta, isRemote ? args.source : path.basename(videoPath));
+        }
+        // ─── Frame extraction mode ──────────────────────────────────────
+        const outputDir = resolveOutputDir(TOOL_DIRS.frames, args.output_path);
+        const baseName = args.filename
+            ? safeName(args.filename)
+            : `frame_${Date.now()}`;
+        try {
+            context.metadata({ title: `🎬 Extraction frames...` });
+            // Get metadata for context
+            const meta = extractMetadata(videoPath);
+            const extractedFiles = extractWithSystemFFmpeg(videoPath, outputDir, baseName, {
+                at_time: args.at_time,
+                start: args.start,
+                end: args.end,
+                fps: args.fps,
+            });
+            // Cleanup temp video
+            if (isRemote && fs.existsSync(videoPath)) {
+                try {
+                    fs.unlinkSync(videoPath);
+                }
+                catch { }
+            }
+            if (extractedFiles.length === 0) {
+                return `❌ Aucune frame extraite. Vérifiez vos timestamps et la source vidéo.`;
+            }
+            const totalSize = extractedFiles.reduce((sum, f) => sum + fs.statSync(f).size, 0);
+            const fileList = extractedFiles.length <= 5
+                ? extractedFiles.map(f => `  📷 ${path.basename(f)}`).join('\n')
+                : [
+                    ...extractedFiles.slice(0, 3).map(f => `  📷 ${path.basename(f)}`),
+                    `  ... et ${extractedFiles.length - 3} de plus`,
+                ].join('\n');
+            const lines = [
+                `🎬 Frames Extraites`,
+                `━━━━━━━━━━━━━━━━━━━`,
+                `Source: ${isRemote ? args.source : path.basename(videoPath)}`,
+            ];
+            // Add video metadata if available
+            if (meta) {
+                lines.push(`Vidéo: ${meta.width}×${meta.height} • ${meta.fps} fps • ${meta.durationStr}`);
+            }
+            lines.push(`Frames: ${extractedFiles.length}`, `Dossier: ${outputDir}`, `Taille totale: ${formatFileSize(totalSize)}`, `Fichiers:`, fileList, ``, `Coût: Gratuit (ffmpeg local)`);
+            return lines.join('\n');
+        }
+        catch (err) {
+            if (isRemote && fs.existsSync(videoPath)) {
+                try {
+                    fs.unlinkSync(videoPath);
+                }
+                catch { }
+            }
+            return `❌ Erreur extraction: ${err.message}`;
+        }
+    },
+});

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

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