opencode-pollinations-plugin 6.2.7 → 6.3.0

package/dist/tools/pollinations/gen_edit_image_free.js

@@ -0,0 +1,146 @@
+/**
+ * gen_edit_image_free — Always-Free image generation & editing (BONUS tool)
+ *
+ * Independent FREE-bucket tool: works for ANY OpenCode model, with or WITHOUT a
+ * Pollinations API key. Acts as an "always free" fallback for image gen/edit,
+ * outside the Pollinations economy (no Pollen, no cost guard).
+ *
+ * Backed by a public image playground (reverse-engineered open endpoint).
+ * Direct-only: the request goes from the END USER's IP, respecting the
+ * playground's own 20-generations/IP/day free limit (gen + edit SHARE the same
+ * counter). Past the daily quota, prefer Pollinations models.
+ */
+import { tool } from '@opencode-ai/plugin/tool';
+import * as fs from 'fs';
+import * as path from 'path';
+import { httpsGet, httpsPost, ensureDir, generateFilename, getDefaultOutputDir, formatFileSize, sanitizeFilename, } from './shared.js';
+import { emitStatusToast } from '../../server/toast.js';
+import { t } from '../../locales/index.js';
+// ─── Constants ─────────────────────────────────────────────────────────────
+const PLAYGROUND = 'https://p-image-playground-production.up.railway.app';
+const STATUS_URL = `${PLAYGROUND}/api/generation-status`;
+const GEN_URL = `${PLAYGROUND}/api/generate-image`;
+const EDIT_URL = `${PLAYGROUND}/api/generate-image-edit`;
+const VALID_RATIOS = ['16:9', '1:1', '9:16'];
+// ─── Helpers ─────────────────────────────────────────────────────────────
+async function fetchQuota() {
+    try {
+        const res = await httpsGet(STATUS_URL);
+        return JSON.parse(res.data.toString());
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Normalize an image input into a data: URI.
+ * Accepts: data: URIs (passthrough), local file paths, http(s) URLs (downloaded).
+ */
+async function toDataUri(img) {
+    if (img.startsWith('data:'))
+        return img;
+    if (/^https?:\/\//i.test(img)) {
+        const res = await httpsGet(img);
+        const ext = (img.split('?')[0].split('.').pop() || 'jpeg').toLowerCase();
+        const mime = ext === 'png' ? 'image/png' : ext === 'webp' ? 'image/webp' : 'image/jpeg';
+        return `data:${mime};base64,${res.data.toString('base64')}`;
+    }
+    if (fs.existsSync(img)) {
+        const ext = path.extname(img).toLowerCase().replace('.', '');
+        const mime = ext === 'png' ? 'image/png' : ext === 'webp' ? 'image/webp' : 'image/jpeg';
+        return `data:${mime};base64,${fs.readFileSync(img).toString('base64')}`;
+    }
+    // Assume already raw base64
+    return img;
+}
+// ─── Tool Definition ──────────────────────────────────────────────────────
+export const genEditImageFreeTool = tool({
+    description: t('tools.gen_edit_image_free.desc'),
+    args: {
+        prompt: tool.schema.string().describe(t('tools.gen_edit_image_free.arg_prompt')),
+        images: tool.schema.array(tool.schema.string()).optional()
+            .describe(t('tools.gen_edit_image_free.arg_images')),
+        aspect_ratio: tool.schema.enum(['16:9', '1:1', '9:16']).optional()
+            .describe(t('tools.gen_edit_image_free.arg_aspect')),
+        save_to: tool.schema.string().optional().describe(t('tools.gen_edit_image_free.arg_save_to')),
+        filename: tool.schema.string().optional().describe(t('tools.gen_edit_image_free.arg_filename')),
+    },
+    async execute(args, context) {
+        const isEdit = Array.isArray(args.images) && args.images.length > 0;
+        const mode = isEdit ? 'edit' : 'generate';
+        // Validate edit input count (playground supports 1-3)
+        if (isEdit && args.images.length > 3) {
+            return t('tools.gen_edit_image_free.too_many_images');
+        }
+        // 1. Check the per-IP daily quota (read-only, free)
+        const quota = await fetchQuota();
+        if (quota && !quota.canGenerate) {
+            return t('tools.gen_edit_image_free.quota_exhausted', { max: quota.max });
+        }
+        context.metadata({ title: `🆓 ${isEdit ? 'Edit' : 'Image'} (free)` });
+        emitStatusToast('info', t('tools.gen_edit_image_free.working', { mode }), '🆓 gen_edit_image_free');
+        try {
+            // 2. Build request and call the playground (from the user's IP)
+            let apiResp;
+            if (isEdit) {
+                const processed = await Promise.all(args.images.map(toDataUri));
+                const res = await httpsPost(EDIT_URL, { prompt: args.prompt, images: processed });
+                apiResp = JSON.parse(res.data.toString());
+            }
+            else {
+                const aspect = args.aspect_ratio && VALID_RATIOS.includes(args.aspect_ratio)
+                    ? args.aspect_ratio : '16:9';
+                const res = await httpsPost(GEN_URL, {
+                    prompt: args.prompt,
+                    aspect_ratio: aspect,
+                    disable_safety_checker: false,
+                });
+                apiResp = JSON.parse(res.data.toString());
+            }
+            if (!apiResp || !apiResp.success || !apiResp.imageUrl) {
+                const reason = apiResp?.error || 'unknown';
+                emitStatusToast('error', t('tools.gen_edit_image_free.failed', { error: String(reason).substring(0, 60) }), '🆓 gen_edit_image_free');
+                return t('tools.gen_edit_image_free.api_error', { error: String(reason) });
+            }
+            // 3. Download the produced image and save it locally
+            const dl = await httpsGet(apiResp.imageUrl);
+            let outputDir = getDefaultOutputDir('images');
+            let filename = args.filename ? sanitizeFilename(args.filename) : undefined;
+            if (args.save_to) {
+                if (args.save_to.match(/\.(png|jpe?g|webp)$/i)) {
+                    outputDir = path.dirname(args.save_to);
+                    filename = path.basename(args.save_to);
+                }
+                else {
+                    outputDir = args.save_to;
+                }
+            }
+            ensureDir(outputDir);
+            filename = filename || generateFilename(isEdit ? 'edit' : 'image', 'free', 'jpg');
+            const filePath = path.join(outputDir, filename.includes('.') ? filename : `${filename}.jpg`);
+            fs.writeFileSync(filePath, dl.data);
+            // 4. Re-read quota for an accurate "remaining" figure
+            const after = await fetchQuota();
+            const fileSize = fs.statSync(filePath).size;
+            const lines = [];
+            lines.push(t(isEdit ? 'tools.gen_edit_image_free.res_title_edit' : 'tools.gen_edit_image_free.res_title_gen'));
+            lines.push('━━━━━━━━━━━━━━━━━━');
+            lines.push(t('tools.gen_edit_image_free.res_prompt', { prompt: args.prompt.substring(0, 100) }));
+            lines.push(t('tools.gen_edit_image_free.res_file', { path: filePath }));
+            lines.push(t('tools.gen_edit_image_free.res_size', { size: formatFileSize(fileSize) }));
+            if (after) {
+                lines.push(t('tools.gen_edit_image_free.res_quota', { remaining: after.remaining, max: after.max }));
+            }
+            lines.push('');
+            lines.push(t('tools.gen_edit_image_free.res_note'));
+            emitStatusToast('success', t('tools.gen_edit_image_free.success', { mode }), '🆓 gen_edit_image_free', { filePath });
+            return lines.join('\n');
+        }
+        catch (err) {
+            const msg = err.message || String(err);
+            emitStatusToast('error', t('tools.gen_edit_image_free.failed', { error: msg.substring(0, 60) }), '🆓 gen_edit_image_free');
+            // Graceful degradation: explicitly point to Pollinations models
+            return t('tools.gen_edit_image_free.degraded', { error: msg.substring(0, 150) });
+        }
+    },
+});

package/dist/tools/pollinations/gen_video.js

@@ -15,7 +15,7 @@
 import { tool } from '@opencode-ai/plugin/tool';
 import * as fs from 'fs';
 import * as path from 'path';
-import { getApiKey, httpsGet, ensureDir, generateFilename, getDefaultOutputDir, formatCost, formatFileSize, estimateVideoCost, extractCostFromHeaders, isCostEstimatorEnabled, supportsI2V, requiresI2V, validateAspectRatio, getDurationRange, getVideoModels, fetchEnterBalance, sanitizeFilename, validateHttpUrl, } from './shared.js';
+import { getApiKey, httpsGet, ensureDir, generateFilename, getDefaultOutputDir, formatCost, formatFileSize, estimateVideoCost, extractCostFromHeaders, isCostEstimatorEnabled, supportsI2V, requiresI2V, getDurationRange, getVideoModels, fetchEnterBalance, sanitizeFilename, validateHttpUrl, } from './shared.js';
 import { loadConfig } from '../../server/config.js';
 import { checkCostControl, isTokenBased } from './cost-guard.js';
 import { emitStatusToast } from '../../server/toast.js';
@@ -58,7 +58,7 @@ export const polliGenVideoTool = tool({
             return t('tools.polli_gen_video.invalid_duration', { model, duration, min: minDuration, max: maxDuration });
         }
         // Validate aspect ratio (for known models; beta models accept any)
-        if (!isBetaModel && !validateAspectRatio(model, aspectRatio)) {
+        if (!isBetaModel && !modelConfig.aspectRatios.includes(aspectRatio)) {
             return t('tools.polli_gen_video.invalid_aspect', { model, aspect: aspectRatio, supported: modelConfig.aspectRatios.join(', ') });
         }
         // Check I2V requirements & validation

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

@@ -0,0 +1,19 @@
+/**
+ * gen_video_free — Always-Free video generation (BONUS tool)
+ *
+ * Independent FREE-bucket tool: works for ANY OpenCode model, with or WITHOUT a
+ * Pollinations API key. "Always free" video generation outside the Pollinations
+ * economy (no Pollen, no cost guard).
+ *
+ * Backed by a public Pruna playground (reverse-engineered open endpoint),
+ * direct-only from the END USER's IP, respecting the playground's own
+ * 5-generations/IP/day free limit (SEPARATE from the image 20/day counter).
+ *
+ * Flow (async): POST multipart /api/p-video/generate -> { id }
+ *               poll GET /api/p-video/status/{id} -> { status, output }
+ *               download `output` mp4.
+ *
+ * Supports optional image (first-frame / reference) and optional audio join.
+ */
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare const genVideoFreeTool: ToolDefinition;

package/dist/tools/pollinations/gen_video_free.js

@@ -0,0 +1,246 @@
+/**
+ * gen_video_free — Always-Free video generation (BONUS tool)
+ *
+ * Independent FREE-bucket tool: works for ANY OpenCode model, with or WITHOUT a
+ * Pollinations API key. "Always free" video generation outside the Pollinations
+ * economy (no Pollen, no cost guard).
+ *
+ * Backed by a public Pruna playground (reverse-engineered open endpoint),
+ * direct-only from the END USER's IP, respecting the playground's own
+ * 5-generations/IP/day free limit (SEPARATE from the image 20/day counter).
+ *
+ * Flow (async): POST multipart /api/p-video/generate -> { id }
+ *               poll GET /api/p-video/status/{id} -> { status, output }
+ *               download `output` mp4.
+ *
+ * Supports optional image (first-frame / reference) and optional audio join.
+ */
+import { tool } from '@opencode-ai/plugin/tool';
+import * as https from 'https';
+import * as fs from 'fs';
+import * as path from 'path';
+import { httpsGet, ensureDir, generateFilename, getDefaultOutputDir, formatFileSize, sanitizeFilename, } from './shared.js';
+import { emitStatusToast } from '../../server/toast.js';
+import { t } from '../../locales/index.js';
+// ─── Constants ─────────────────────────────────────────────────────────────
+const PLAYGROUND = 'https://pruna-playground-production-861e.up.railway.app';
+const STATUS_URL = `${PLAYGROUND}/api/generation-status?model=p-video`;
+const GEN_URL = `${PLAYGROUND}/api/p-video/generate`;
+const JOB_STATUS = (id) => `${PLAYGROUND}/api/p-video/status/${id}`;
+const VALID_RATIOS = ['16:9', '9:16', '1:1'];
+const VALID_RES = ['480p', '720p', '1080p'];
+const POLL_INTERVAL_MS = 4000;
+const POLL_MAX_ATTEMPTS = 75; // ~5 min ceiling
+// ─── Helpers ─────────────────────────────────────────────────────────────
+async function fetchQuota() {
+    try {
+        const res = await httpsGet(STATUS_URL);
+        return JSON.parse(res.data.toString());
+    }
+    catch {
+        return null;
+    }
+}
+/** Resolve an image/audio input (local path | http(s) URL | data: URI) to a Buffer + mime + filename. */
+async function resolveAsset(input, kind) {
+    // data: URI
+    const dataMatch = input.match(/^data:([^;]+);base64,(.+)$/);
+    if (dataMatch) {
+        const mime = dataMatch[1];
+        const ext = mime.split('/')[1] || (kind === 'image' ? 'jpeg' : 'mp3');
+        return { buf: Buffer.from(dataMatch[2], 'base64'), mime, filename: `${kind}.${ext}` };
+    }
+    // http(s) URL
+    if (/^https?:\/\//i.test(input)) {
+        const res = await httpsGet(input);
+        const ext = (input.split('?')[0].split('.').pop() || (kind === 'image' ? 'jpeg' : 'mp3')).toLowerCase();
+        return { buf: res.data, mime: mimeFor(ext, kind), filename: `${kind}.${ext}` };
+    }
+    // local file
+    if (fs.existsSync(input)) {
+        const ext = path.extname(input).toLowerCase().replace('.', '') || (kind === 'image' ? 'jpeg' : 'mp3');
+        return { buf: fs.readFileSync(input), mime: mimeFor(ext, kind), filename: path.basename(input) };
+    }
+    throw new Error(`Asset not found: ${input}`);
+}
+function mimeFor(ext, kind) {
+    const e = ext.toLowerCase();
+    if (kind === 'image') {
+        if (e === 'png')
+            return 'image/png';
+        if (e === 'webp')
+            return 'image/webp';
+        return 'image/jpeg';
+    }
+    if (e === 'wav')
+        return 'audio/wav';
+    if (e === 'ogg')
+        return 'audio/ogg';
+    return 'audio/mpeg';
+}
+/** Custom multipart POST: handles text fields AND typed file parts (image/audio). */
+function multipartPost(url, textFields, files) {
+    return new Promise((resolve, reject) => {
+        const parsed = new URL(url);
+        const boundary = `----OCFormBoundary${Date.now()}${Math.random().toString(16).slice(2)}`;
+        const parts = [];
+        for (const [k, v] of Object.entries(textFields)) {
+            parts.push(Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="${k}"\r\n\r\n${v}\r\n`));
+        }
+        for (const f of files) {
+            parts.push(Buffer.from(`--${boundary}\r\nContent-Disposition: form-data; name="${f.field}"; filename="${f.filename}"\r\nContent-Type: ${f.mime}\r\n\r\n`));
+            parts.push(f.buf);
+            parts.push(Buffer.from('\r\n'));
+        }
+        parts.push(Buffer.from(`--${boundary}--\r\n`));
+        const body = Buffer.concat(parts);
+        const req = https.request({
+            hostname: parsed.hostname,
+            path: parsed.pathname + parsed.search,
+            method: 'POST',
+            headers: {
+                'Content-Type': `multipart/form-data; boundary=${boundary}`,
+                'Content-Length': body.length,
+                'User-Agent': 'OpenCode-Pollinations-Plugin',
+                'Origin': PLAYGROUND,
+            },
+        }, (res) => {
+            const chunks = [];
+            res.on('data', (c) => chunks.push(c));
+            res.on('end', () => {
+                const txt = Buffer.concat(chunks).toString();
+                if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                    try {
+                        resolve(JSON.parse(txt));
+                    }
+                    catch {
+                        reject(new Error('Bad JSON: ' + txt.slice(0, 150)));
+                    }
+                }
+                else {
+                    reject(new Error(`HTTP ${res.statusCode}: ${txt.slice(0, 150)}`));
+                }
+            });
+        });
+        req.on('error', reject);
+        req.setTimeout(120000, () => { req.destroy(); reject(new Error('Upload timeout')); });
+        req.write(body);
+        req.end();
+    });
+}
+async function pollJob(id) {
+    for (let i = 0; i < POLL_MAX_ATTEMPTS; i++) {
+        await new Promise(r => setTimeout(r, POLL_INTERVAL_MS));
+        try {
+            const res = await httpsGet(JOB_STATUS(id));
+            const j = JSON.parse(res.data.toString());
+            if (j.status === 'succeeded' && j.output)
+                return j.output;
+            if (j.status === 'failed' || j.status === 'canceled' || j.error) {
+                throw new Error(j.error || `job ${j.status}`);
+            }
+        }
+        catch (e) {
+            // transient network error during polling: keep trying unless it's a job failure
+            if (/job (failed|canceled)/.test(e.message))
+                throw e;
+        }
+    }
+    throw new Error('Polling timeout (video took too long)');
+}
+// ─── Tool Definition ──────────────────────────────────────────────────────
+export const genVideoFreeTool = tool({
+    description: t('tools.gen_video_free.desc'),
+    args: {
+        prompt: tool.schema.string().describe(t('tools.gen_video_free.arg_prompt')),
+        image: tool.schema.string().optional().describe(t('tools.gen_video_free.arg_image')),
+        audio: tool.schema.string().optional().describe(t('tools.gen_video_free.arg_audio')),
+        duration: tool.schema.number().min(1).max(10).optional().describe(t('tools.gen_video_free.arg_duration')),
+        aspect_ratio: tool.schema.enum(['16:9', '9:16', '1:1']).optional().describe(t('tools.gen_video_free.arg_aspect')),
+        resolution: tool.schema.enum(['480p', '720p', '1080p']).optional().describe(t('tools.gen_video_free.arg_resolution')),
+        save_to: tool.schema.string().optional().describe(t('tools.gen_video_free.arg_save_to')),
+        filename: tool.schema.string().optional().describe(t('tools.gen_video_free.arg_filename')),
+    },
+    async execute(args, context) {
+        // 1. Quota check (read-only, free, separate 5/day counter)
+        const quota = await fetchQuota();
+        if (quota && !quota.canGenerate) {
+            return t('tools.gen_video_free.quota_exhausted', { max: quota.max });
+        }
+        context.metadata({ title: '🆓 Video (free)' });
+        emitStatusToast('info', t('tools.gen_video_free.working'), '🆓 gen_video_free');
+        try {
+            // 2. Build multipart payload (contract captured from the playground)
+            const aspect = args.aspect_ratio && VALID_RATIOS.includes(args.aspect_ratio) ? args.aspect_ratio : '16:9';
+            const resolution = args.resolution && VALID_RES.includes(args.resolution) ? args.resolution : '720p';
+            const duration = String(args.duration ?? 5);
+            const textFields = {
+                prompt: args.prompt,
+                duration,
+                aspect_ratio: aspect,
+                resolution,
+                fps: '24',
+                draft: 'false',
+                prompt_upsampling: 'true',
+                save_audio: 'true',
+            };
+            const files = [];
+            if (args.image) {
+                const a = await resolveAsset(args.image, 'image');
+                files.push({ field: 'image', buf: a.buf, mime: a.mime, filename: a.filename });
+            }
+            if (args.audio) {
+                const a = await resolveAsset(args.audio, 'audio');
+                files.push({ field: 'audio', buf: a.buf, mime: a.mime, filename: a.filename });
+            }
+            // 3. Launch job
+            const job = await multipartPost(GEN_URL, textFields, files);
+            if (!job || !job.id) {
+                return t('tools.gen_video_free.api_error', { error: JSON.stringify(job).slice(0, 120) });
+            }
+            // 4. Poll until ready
+            const videoUrl = await pollJob(job.id);
+            // 5. Download the mp4
+            const dl = await httpsGet(videoUrl);
+            let outputDir = getDefaultOutputDir('videos');
+            let filename = args.filename ? sanitizeFilename(args.filename) : undefined;
+            if (args.save_to) {
+                if (args.save_to.match(/\.(mp4|webm|mov)$/i)) {
+                    outputDir = path.dirname(args.save_to);
+                    filename = path.basename(args.save_to);
+                }
+                else {
+                    outputDir = args.save_to;
+                }
+            }
+            ensureDir(outputDir);
+            filename = filename || generateFilename('video', 'free', 'mp4');
+            const filePath = path.join(outputDir, filename.includes('.') ? filename : `${filename}.mp4`);
+            fs.writeFileSync(filePath, dl.data);
+            const after = await fetchQuota();
+            const fileSize = fs.statSync(filePath).size;
+            const lines = [];
+            lines.push(t('tools.gen_video_free.res_title'));
+            lines.push('━━━━━━━━━━━━━━━━━━');
+            lines.push(t('tools.gen_video_free.res_prompt', { prompt: args.prompt.substring(0, 100) }));
+            lines.push(t('tools.gen_video_free.res_params', { duration, resolution, aspect }));
+            if (args.image)
+                lines.push(t('tools.gen_video_free.res_image'));
+            if (args.audio)
+                lines.push(t('tools.gen_video_free.res_audio'));
+            lines.push(t('tools.gen_video_free.res_file', { path: filePath }));
+            lines.push(t('tools.gen_video_free.res_size', { size: formatFileSize(fileSize) }));
+            if (after)
+                lines.push(t('tools.gen_video_free.res_quota', { remaining: after.remaining, max: after.max }));
+            lines.push('');
+            lines.push(t('tools.gen_video_free.res_note'));
+            emitStatusToast('success', t('tools.gen_video_free.success'), '🆓 gen_video_free', { filePath });
+            return lines.join('\n');
+        }
+        catch (err) {
+            const msg = err.message || String(err);
+            emitStatusToast('error', t('tools.gen_video_free.failed', { error: msg.substring(0, 60) }), '🆓 gen_video_free');
+            return t('tools.gen_video_free.degraded', { error: msg.substring(0, 150) });
+        }
+    },
+});

package/dist/tools/pollinations/polli_config.js

@@ -36,7 +36,7 @@ Use 'action=update' to change these. NEVER confuse Chat Mode with Tools Protecti
         costThreshold: tool.schema.number().optional().describe('Cost threshold in USD/🌼 above which confirmation is required'),
         thresholdsTier: tool.schema.number().optional().describe('Warning threshold PERCENTAGE (e.g. 10 for 10%) for Free Tier.'),
         thresholdsWallet: tool.schema.number().optional().describe('Warning threshold PERCENTAGE (e.g. 50 for 50%) for Wallet balance.'),
-        lang: tool.schema.enum(['en', 'fr', 'es', 'de', 'it']).optional().describe('Plugin language for commands and toasts (en, fr, es, de, it).')
+        lang: tool.schema.enum(['en', 'fr', 'es', 'de', 'it', 'zh']).optional().describe('Plugin language for commands and toasts (en, fr, es, de, it, zh).')
     },
     async execute(args, context) {
         if (args.action === 'view') {

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

@@ -0,0 +1,13 @@
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+/**
+ * polli_login — Device-flow login as a TOOL (callable by ANY OpenCode model).
+ *
+ * Two-step pattern so the agent can both SHOW the code and KNOW when connected:
+ *   1. polli_login()            -> returns code + URL (show it to the user)
+ *   2. polli_login(wait:true)   -> attaches to the running poller and RETURNS
+ *                                  "✅ connected" once the user authorizes.
+ *
+ * Shares the exact same logic as the `/poll login` command. The login is
+ * attributed to this app (embedded pk_) and never spends the developer's Pollen.
+ */
+export declare const polliLoginTool: ToolDefinition;

package/dist/tools/pollinations/polli_login.js

@@ -0,0 +1,30 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import { startDeviceLogin, awaitDeviceLogin } from '../../server/commands.js';
+import { t } from '../../locales/index.js';
+/**
+ * polli_login — Device-flow login as a TOOL (callable by ANY OpenCode model).
+ *
+ * Two-step pattern so the agent can both SHOW the code and KNOW when connected:
+ *   1. polli_login()            -> returns code + URL (show it to the user)
+ *   2. polli_login(wait:true)   -> attaches to the running poller and RETURNS
+ *                                  "✅ connected" once the user authorizes.
+ *
+ * Shares the exact same logic as the `/poll login` command. The login is
+ * attributed to this app (embedded pk_) and never spends the developer's Pollen.
+ */
+export const polliLoginTool = tool({
+    description: t('tools.polli_login.desc'),
+    args: {
+        wait: tool.schema.boolean().optional()
+            .describe(t('tools.polli_login.arg_wait')),
+    },
+    async execute(args) {
+        // Wait mode: attach to an in-progress login and report the final outcome.
+        if (args.wait) {
+            return await awaitDeviceLogin();
+        }
+        // Start mode: kick off the device flow and return the code + URL to show.
+        const res = await startDeviceLogin();
+        return res.response || res.error || 'Login could not be started.';
+    },
+});

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

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+export declare function buildQuestsReport(filter?: 'all' | 'available' | 'claimable'): Promise<string>;
+export declare const polliQuestsTool: ToolDefinition;

package/dist/tools/pollinations/polli_quests.js

@@ -0,0 +1,135 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import * as https from 'https';
+import { loadConfig } from '../../server/config.js';
+import { t } from '../../locales/index.js';
+// ─── API ───────────────────────────────────────────────────────────────────
+function fetchQuests(apiKey) {
+    return new Promise((resolve, reject) => {
+        const req = https.request({
+            hostname: 'gen.pollinations.ai',
+            path: '/account/quests',
+            method: 'GET',
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'User-Agent': 'opencode-pollinations-plugin'
+            }
+        }, (res) => {
+            let data = '';
+            res.on('data', (c) => data += c);
+            res.on('end', () => {
+                if (res.statusCode && res.statusCode >= 400) {
+                    reject(new Error(`API ${res.statusCode}: ${data.substring(0, 120)}`));
+                    return;
+                }
+                try {
+                    const parsed = JSON.parse(data);
+                    resolve(Array.isArray(parsed?.quests) ? parsed.quests : []);
+                }
+                catch (e) {
+                    reject(new Error(`Parse error: ${e.message}`));
+                }
+            });
+        });
+        req.on('error', (e) => reject(new Error(`Network: ${e.message}`)));
+        req.setTimeout(10000, () => req.destroy(new Error('Timeout')));
+        req.end();
+    });
+}
+// ─── Category labels (emoji map) ────────────────────────────────────────────
+const CATEGORY_EMOJI = {
+    setup: '🔧', grow: '🌱', build: '🏗️', contribute: '🤝', community: '💬', easteregg: '🥚'
+};
+// ─── Shared report builder (used by both the tool and the /poll quests command) ───
+export async function buildQuestsReport(filter = 'all') {
+    const config = loadConfig();
+    if (!config.apiKey) {
+        return t('tools.polli_quests.no_key');
+    }
+    let quests;
+    try {
+        quests = await fetchQuests(config.apiKey);
+    }
+    catch (e) {
+        return t('tools.polli_quests.error', { error: e.message });
+    }
+    if (quests.length === 0) {
+        return t('tools.polli_quests.empty');
+    }
+    // Compute claimable (earned but not yet claimed) total
+    let claimablePollen = 0;
+    let claimableCount = 0;
+    for (const q of quests) {
+        if (q.reward && !q.reward.claimedAt) {
+            claimablePollen += q.reward.pollenAmount || 0;
+            claimableCount++;
+        }
+    }
+    const lines = [];
+    lines.push(t('tools.polli_quests.title'));
+    lines.push('');
+    // Highlight claimable Pollen (the porter message)
+    if (claimableCount > 0) {
+        lines.push(t('tools.polli_quests.claimable', {
+            count: claimableCount,
+            pollen: claimablePollen.toFixed(2)
+        }));
+        lines.push('');
+    }
+    if (filter === 'claimable') {
+        const claimables = quests.filter(q => q.reward && !q.reward.claimedAt);
+        if (claimables.length === 0)
+            return t('tools.polli_quests.none_claimable');
+        for (const q of claimables) {
+            lines.push(`- 🎁 **${q.title}** — ${(q.reward.pollenAmount).toFixed(2)} 🌻 (${q.balanceBucket})`);
+        }
+        lines.push('');
+        lines.push(t('tools.polli_quests.claim_hint'));
+        return lines.join('\n');
+    }
+    // Group by category
+    const byCat = new Map();
+    for (const q of quests) {
+        if (filter === 'available' && q.state !== 'available')
+            continue;
+        if (!byCat.has(q.category))
+            byCat.set(q.category, []);
+        byCat.get(q.category).push(q);
+    }
+    for (const [cat, items] of byCat) {
+        const emoji = CATEGORY_EMOJI[cat] || '•';
+        lines.push(`### ${emoji} ${cat.charAt(0).toUpperCase() + cat.slice(1)}`);
+        for (const q of items) {
+            let mark;
+            if (q.reward && !q.reward.claimedAt)
+                mark = '🎁'; // earned, unclaimed
+            else if (q.reward && q.reward.claimedAt)
+                mark = '✅'; // claimed
+            else if (q.state === 'completed')
+                mark = '✔️';
+            else if (q.state === 'coming_soon')
+                mark = '🔜';
+            else
+                mark = '⬜'; // available, not done
+            const reward = q.rewardAmount > 0 ? ` (+${q.rewardAmount} 🌻)` : '';
+            lines.push(`- ${mark} ${q.title}${reward}`);
+        }
+        lines.push('');
+    }
+    lines.push(t('tools.polli_quests.legend'));
+    if (claimableCount > 0) {
+        lines.push('');
+        lines.push(t('tools.polli_quests.claim_hint'));
+    }
+    return lines.join('\n');
+}
+// ─── Tool ────────────────────────────────────────────────────────────────
+export const polliQuestsTool = tool({
+    description: t('tools.polli_quests.desc'),
+    args: {
+        filter: tool.schema.enum(['all', 'available', 'claimable']).optional()
+            .describe(t('tools.polli_quests.arg_filter'))
+    },
+    async execute(args) {
+        return buildQuestsReport(args.filter || 'all');
+    }
+});

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "opencode-pollinations-plugin",
     "displayName": "Pollinations",
-    "version": "6.2.7",
+    "version": "6.3.0",
     "description": "Native Pollinations.ai Provider Plugin for OpenCode",
     "publisher": "pollinations",
     "repository": {
@@ -61,4 +61,4 @@
         "@types/qrcode": "^1.5.6",
         "typescript": "^5.0.0"
     }
-}
+}

package/dist/server/index.d.ts

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