opencode-pollinations-plugin 5.9.0 → 6.0.0-beta.1

package/README.md

@@ -1,4 +1,4 @@
-# 🌸 Pollinations AI Plugin for OpenCode (v5.6.0)
+# 🌸 Pollinations AI Plugin for OpenCode (v5.9.0)
 
 <div align="center">
   <img src="https://avatars.githubusercontent.com/u/88394740?s=400&v=4" alt="Pollinations.ai Logo" width="200">
@@ -134,8 +134,9 @@ OpenCode uses NPM as its registry. To publish:
 
 ### 1. The Basics (Free Mode)
 Just type in the chat. You are in **Manual Mode** by default.
-- Model: `openai` (GPT-4o Mini equivalent)
-- Model: `mistral` (Mistral Nemo)
+- Model: `openai-fast` (GPT-OSS 20b)
+- Model: `mistral` (Mistral Small 3.1)
+- ...
 
 ### 🔑 Configuration (API Key)
 
@@ -155,6 +156,7 @@ Just type in the chat. You are in **Manual Mode** by default.
 
 ## 🔗 Links
 
+- **Sign up Pollinations Beta (more and best free tiers access and paids models)**: [pollinations.ai](https://enter.pollinations.ai)
 - **Pollinations Website**: [pollinations.ai](https://pollinations.ai)
 - **Discord Community**: [Join us!](https://discord.gg/pollinations-ai-885844321461485618)
 - **OpenCode Ecosystem**: [opencode.ai](https://opencode.ai/docs/ecosystem#plugins)

package/dist/index.js

@@ -6,6 +6,7 @@ import { handleChatCompletion } from './server/proxy.js';
 import { createToastHooks, setGlobalClient } from './server/toast.js';
 import { createStatusHooks } from './server/status.js';
 import { createCommandHooks } from './server/commands.js';
+import { createToolRegistry } from './tools/index.js';
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);
 const LOG_FILE = '/tmp/opencode_pollinations_v4.log';
@@ -84,7 +85,11 @@ export const PollinationsPlugin = async (ctx) => {
     setGlobalClient(ctx.client);
     const toastHooks = createToastHooks(ctx.client);
     const commandHooks = createCommandHooks();
+    // Build tool registry (conditional on API key presence)
+    const toolRegistry = createToolRegistry();
+    log(`[Tools] ${Object.keys(toolRegistry).length} tools registered`);
     return {
+        tool: toolRegistry,
         async config(config) {
             log("[Hook] config() called");
             // STARTUP only - No complex hot reload logic

package/dist/server/generate-config.js

@@ -214,6 +214,13 @@ function mapModel(raw, prefix, namePrefix) {
         // Also keep variant just in case
         modelObj.variants.bedrock_safe = { options: { maxTokens: 8000 } };
     }
+    // BEDROCK/ENTERPRISE LIMITS (Chickytutor only)
+    if (rawId.includes('chickytutor')) {
+        modelObj.limit = {
+            output: 8192,
+            context: 128000
+        };
+    }
     // NOMNOM FIX: User reported error if max_tokens is missing.
     // Also it is a 'Gemini-scrape' model, so we treat it similar to Gemini but with strict limit.
     if (rawId.includes('nomnom') || rawId.includes('scrape')) {

package/dist/server/proxy.js

@@ -78,6 +78,23 @@ function dereferenceSchema(schema, rootDefs) {
             schema.description = (schema.description || "") + " [Ref Failed]";
         }
     }
+    // VERTEX FIX: 'const' not supported -> convert to 'enum'
+    if (schema.const !== undefined) {
+        schema.enum = [schema.const];
+        delete schema.const;
+    }
+    // VERTEX FIX: 'anyOf' must be exclusive (no other siblings)
+    if (schema.anyOf || schema.oneOf) {
+        // Vertex demands strict exclusivity.
+        // We keep 'definitions'/'$defs' if present at root (though unlikely here)
+        // But for a property node, we must strip EVERYTHING else.
+        const keys = Object.keys(schema);
+        keys.forEach(k => {
+            if (k !== 'anyOf' && k !== 'oneOf' && k !== 'definitions' && k !== '$defs') {
+                delete schema[k];
+            }
+        });
+    }
     if (schema.properties) {
         for (const key in schema.properties) {
             schema.properties[key] = dereferenceSchema(schema.properties[key], rootDefs);
@@ -86,6 +103,15 @@ function dereferenceSchema(schema, rootDefs) {
     if (schema.items) {
         schema.items = dereferenceSchema(schema.items, rootDefs);
     }
+    if (schema.anyOf) {
+        schema.anyOf = schema.anyOf.map((s) => dereferenceSchema(s, rootDefs));
+    }
+    if (schema.oneOf) {
+        schema.oneOf = schema.oneOf.map((s) => dereferenceSchema(s, rootDefs));
+    }
+    if (schema.allOf) {
+        schema.allOf = schema.allOf.map((s) => dereferenceSchema(s, rootDefs));
+    }
     if (schema.optional !== undefined)
         delete schema.optional;
     if (schema.title)
@@ -107,6 +133,38 @@ function sanitizeToolsForVertex(tools) {
         return tool;
     });
 }
+function sanitizeToolsForBedrock(tools) {
+    return tools.map(tool => {
+        if (tool.function) {
+            if (!tool.function.description || tool.function.description.length === 0) {
+                tool.function.description = " "; // Force non-empty string
+            }
+        }
+        return tool;
+    });
+}
+function sanitizeSchemaForKimi(schema) {
+    if (!schema || typeof schema !== 'object')
+        return schema;
+    // Kimi Fixes
+    if (schema.title)
+        delete schema.title;
+    // Fix empty objects "{}" which Kimi hates.
+    // If it's an empty object without type, assume string or object?
+    // Often happens with "additionalProperties: {}"
+    if (Object.keys(schema).length === 0) {
+        schema.type = "string"; // Fallback to safe type
+        schema.description = "Any value";
+    }
+    if (schema.properties) {
+        for (const key in schema.properties) {
+            schema.properties[key] = sanitizeSchemaForKimi(schema.properties[key]);
+        }
+    }
+    if (schema.items)
+        sanitizeSchemaForKimi(schema.items);
+    return schema;
+}
 function truncateTools(tools, limit = 120) {
     if (!tools || tools.length <= limit)
         return tools;
@@ -114,12 +172,16 @@ function truncateTools(tools, limit = 120) {
 }
 const MAX_RETRIES = 3;
 const RETRY_DELAY_MS = 1000;
+const FETCH_TIMEOUT_MS = 600000; // 10 Minutes global timeout
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 async function fetchWithRetry(url, options, retries = MAX_RETRIES) {
     try {
-        const response = await fetch(url, options);
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+        const response = await fetch(url, { ...options, signal: controller.signal });
+        clearTimeout(timeoutId);
         if (response.ok)
             return response;
         if (response.status === 404 || response.status === 401 || response.status === 400) {
@@ -380,17 +442,24 @@ export async function handleChatCompletion(req, res, bodyRaw) {
         // LOGIC BLOCK: MODEL SPECIFIC ADAPTATIONS
         // =========================================================
         if (proxyBody.tools && Array.isArray(proxyBody.tools) && proxyBody.tools.length > 0) {
-            // B0. KIMI / MOONSHOT SURGICAL FIX (Restored for Debug)
-            // Tools are ENABLED. We rely on penalties and strict stops to fight loops.
+            // B0. KIMI / MOONSHOT SURGICAL FIX
             if (actualModel.includes("kimi") || actualModel.includes("moonshot")) {
-                log(`[Proxy] Kimi: Tools ENABLED. Applying penalties/stops.`);
+                log(`[Proxy] Kimi: Tools ENABLED. Applying penalties/stops/sanitization.`);
                 proxyBody.frequency_penalty = 1.1;
                 proxyBody.presence_penalty = 0.4;
                 proxyBody.stop = ["<|endoftext|>", "User:", "\nUser", "User :"];
+                // KIMI FIX: Remove 'title' from schema
+                proxyBody.tools = proxyBody.tools.map((t) => {
+                    if (t.function && t.function.parameters) {
+                        t.function.parameters = sanitizeSchemaForKimi(t.function.parameters);
+                    }
+                    return t;
+                });
             }
-            // A. AZURE/OPENAI FIXES
-            if (actualModel.includes("gpt") || actualModel.includes("openai") || actualModel.includes("azure")) {
-                proxyBody.tools = truncateTools(proxyBody.tools, 120);
+            // A. AZURE/OPENAI FIXES + MIDJOURNEY + GROK
+            if (actualModel.includes("gpt") || actualModel.includes("openai") || actualModel.includes("azure") || actualModel.includes("midijourney") || actualModel.includes("grok")) {
+                const limit = (actualModel.includes("midijourney") || actualModel.includes("grok")) ? 128 : 120;
+                proxyBody.tools = truncateTools(proxyBody.tools, limit);
                 if (proxyBody.messages) {
                     proxyBody.messages.forEach((m) => {
                         if (m.tool_calls) {
@@ -405,6 +474,11 @@ export async function handleChatCompletion(req, res, bodyRaw) {
                     });
                 }
             }
+            // BEDROCK FIX (Claude / Nova / ChickyTutor)
+            if (actualModel.includes("claude") || actualModel.includes("nova") || actualModel.includes("bedrock") || actualModel.includes("chickytutor")) {
+                log(`[Proxy] Bedrock: Sanitizing tools description.`);
+                proxyBody.tools = sanitizeToolsForBedrock(proxyBody.tools);
+            }
             // B1. NOMNOM SPECIAL (Disable Grounding, KEEP Search Tool)
             if (actualModel === "nomnom") {
                 proxyBody.tools_config = { google_search_retrieval: { disable: true } };
@@ -412,12 +486,7 @@ export async function handleChatCompletion(req, res, bodyRaw) {
                 proxyBody.tools = sanitizeToolsForVertex(proxyBody.tools || []);
                 log(`[Proxy] Nomnom Fix: Grounding Disabled, Search Tool KEPT.`);
             }
-            // B2. GEMINI FREE / FAST (CRASH FIX: STRICT SANITIZATION)
-            // Restore Tools but REMOVE conflicting ones (Search)
-            // B. GEMINI UNIFIED FIX (Free, Fast, Pro, Enterprise, Legacy)
-            // Handles: "tools" vs "grounding" conflicts, and "infinite loops" via Stop Sequences.
             // B. GEMINI UNIFIED FIX (Free, Fast, Pro, Enterprise, Legacy)
-            // Fixes "Multiple tools" error (Vertex) and "JSON body validation failed" (v5.3.5 regression)
             else if (actualModel.includes("gemini")) {
                 let hasFunctions = false;
                 if (proxyBody.tools && Array.isArray(proxyBody.tools)) {

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

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

package/dist/tools/design/gen_diagram.js

@@ -0,0 +1,97 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import * as https from 'https';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+const SAVE_DIR = path.join(os.homedir(), 'Downloads', 'pollinations', 'diagrams');
+const MERMAID_INK_BASE = 'https://mermaid.ink';
+/**
+ * Encode Mermaid code for mermaid.ink API
+ * Uses base64 encoding of the diagram definition
+ */
+function encodeMermaid(code) {
+    return Buffer.from(code, 'utf-8').toString('base64url');
+}
+/**
+ * Fetch binary content from URL
+ */
+function fetchBinary(url) {
+    return new Promise((resolve, reject) => {
+        const req = https.get(url, { headers: { 'User-Agent': 'OpenCode-Pollinations-Plugin/6.0' } }, (res) => {
+            // Follow redirects
+            if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                return fetchBinary(res.headers.location).then(resolve).catch(reject);
+            }
+            if (res.statusCode && res.statusCode >= 400) {
+                return reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
+            }
+            const chunks = [];
+            res.on('data', (chunk) => chunks.push(chunk));
+            res.on('end', () => resolve(Buffer.concat(chunks)));
+        });
+        req.on('error', reject);
+        req.setTimeout(15000, () => {
+            req.destroy();
+            reject(new Error('Timeout fetching diagram'));
+        });
+    });
+}
+export const genDiagramTool = tool({
+    description: `Render a Mermaid diagram to SVG or PNG image. 
+Uses mermaid.ink (free, no auth required). Supports all Mermaid syntax:
+flowchart, sequenceDiagram, classDiagram, stateDiagram, erDiagram, gantt, pie, mindmap, timeline, etc.
+The diagram code should be valid Mermaid syntax WITHOUT the \`\`\`mermaid fences.`,
+    args: {
+        code: tool.schema.string().describe('Mermaid diagram code (e.g. "graph LR; A-->B; B-->C")'),
+        format: tool.schema.enum(['svg', 'png']).optional().describe('Output format (default: svg)'),
+        theme: tool.schema.enum(['default', 'dark', 'forest', 'neutral']).optional().describe('Diagram theme (default: default)'),
+        filename: tool.schema.string().optional().describe('Custom filename (without extension). Auto-generated if omitted'),
+    },
+    async execute(args, context) {
+        const format = args.format || 'svg';
+        const theme = args.theme || 'default';
+        // Ensure save directory
+        if (!fs.existsSync(SAVE_DIR)) {
+            fs.mkdirSync(SAVE_DIR, { recursive: true });
+        }
+        // Build mermaid.ink URL
+        // For themed rendering, we wrap with config
+        const themedCode = theme !== 'default'
+            ? `%%{init: {'theme': '${theme}'}}%%\n${args.code}`
+            : args.code;
+        const encoded = encodeMermaid(themedCode);
+        const endpoint = format === 'svg' ? 'svg' : 'img';
+        const url = `${MERMAID_INK_BASE}/${endpoint}/${encoded}`;
+        // Generate filename
+        const safeName = args.filename
+            ? args.filename.replace(/[^a-zA-Z0-9_-]/g, '_')
+            : `diagram_${Date.now()}`;
+        const filePath = path.join(SAVE_DIR, `${safeName}.${format}`);
+        try {
+            const data = await fetchBinary(url);
+            if (data.length < 50) {
+                return `❌ Diagram Error: mermaid.ink returned empty/invalid response. Check your Mermaid syntax.`;
+            }
+            fs.writeFileSync(filePath, data);
+            const fileSizeKB = (data.length / 1024).toFixed(1);
+            // Extract diagram type from first line
+            const firstLine = args.code.trim().split('\n')[0].trim();
+            const diagramType = firstLine.replace(/[;\s{].*/g, '');
+            context.metadata({ title: `📊 Diagram: ${diagramType}` });
+            return [
+                `📊 Diagram Rendered`,
+                `━━━━━━━━━━━━━━━━━━━`,
+                `Type: ${diagramType}`,
+                `Theme: ${theme}`,
+                `Format: ${format.toUpperCase()}`,
+                `File: ${filePath}`,
+                `Weight: ${fileSizeKB} KB`,
+                `URL: ${url}`,
+                `Cost: Free (mermaid.ink)`,
+            ].join('\n');
+        }
+        catch (err) {
+            return `❌ Diagram Error: ${err.message}\n💡 Verify your Mermaid syntax at https://mermaid.live`;
+        }
+    },
+});

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

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

package/dist/tools/design/gen_palette.js

@@ -0,0 +1,185 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+const SAVE_DIR = path.join(os.homedir(), 'Downloads', 'pollinations', 'palettes');
+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'),
+    },
+    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);
+        // Ensure save directory
+        if (!fs.existsSync(SAVE_DIR)) {
+            fs.mkdirSync(SAVE_DIR, { recursive: true });
+        }
+        // Save SVG
+        const safeName = args.filename
+            ? args.filename.replace(/[^a-zA-Z0-9_-]/g, '_')
+            : `palette_${hex.replace('#', '')}_${scheme}`;
+        const svgPath = path.join(SAVE_DIR, `${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,60 @@
+import { tool } from '@opencode-ai/plugin/tool';
+import * as QRCode from 'qrcode';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+const SAVE_DIR = path.join(os.homedir(), 'Downloads', 'pollinations', 'qrcodes');
+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'),
+    },
+    async execute(args, context) {
+        const size = args.size || 512;
+        // Ensure save directory exists
+        if (!fs.existsSync(SAVE_DIR)) {
+            fs.mkdirSync(SAVE_DIR, { recursive: true });
+        }
+        // Generate filename
+        const safeName = args.filename
+            ? args.filename.replace(/[^a-zA-Z0-9_-]/g, '_')
+            : `qr_${Date.now()}`;
+        const filePath = path.join(SAVE_DIR, `${safeName}.png`);
+        try {
+            // Generate QR code PNG
+            await QRCode.toFile(filePath, args.content, {
+                width: size,
+                margin: 2,
+                color: {
+                    dark: '#000000',
+                    light: '#ffffff',
+                },
+                errorCorrectionLevel: 'M',
+            });
+            // Get file size
+            const stats = fs.statSync(filePath);
+            const fileSizeKB = (stats.size / 1024).toFixed(1);
+            // Truncate content for display
+            const displayContent = args.content.length > 80
+                ? args.content.substring(0, 77) + '...'
+                : args.content;
+            context.metadata({ title: `🔲 QR Code: ${displayContent}` });
+            return [
+                `🔲 QR Code Generated`,
+                `━━━━━━━━━━━━━━━━━━━`,
+                `Content: ${displayContent}`,
+                `Size: ${size}×${size}px`,
+                `File: ${filePath}`,
+                `Weight: ${fileSizeKB} KB`,
+                `Cost: Free (local generation)`,
+            ].join('\n');
+        }
+        catch (err) {
+            return `❌ QR Code Error: ${err.message}`;
+        }
+    },
+});

package/dist/tools/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Tool Registry — Conditional Injection System
+ *
+ * Free Universe (no key): 7 tools always available
+ * Enter Universe (with key): +5 Pollinations tools
+ *
+ * Tools are injected ONCE at plugin init. Restart needed after /poll connect.
+ */
+/**
+ * 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>;

package/dist/tools/index.js

@@ -0,0 +1,75 @@
+/**
+ * Tool Registry — Conditional Injection System
+ *
+ * Free Universe (no key): 7 tools always available
+ * Enter Universe (with key): +5 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';
+// === ENTER TOOLS (Require API key) ===
+// Phase 4D: Pollinations tools — TO BE IMPLEMENTED
+// import { genImageTool } from './pollinations/gen_image.js';
+// import { genVideoTool } from './pollinations/gen_video.js';
+// import { genAudioTool } from './pollinations/gen_audio.js';
+// import { genMusicTool } from './pollinations/gen_music.js';
+// import { deepsearchTool } from './pollinations/deepsearch.js';
+// import { searchCrawlScrapeTool } from './pollinations/search_crawl_scrape.js';
+import * as fs from 'fs';
+const LOG_FILE = '/tmp/opencode_pollinations_v4.log';
+function log(msg) {
+    try {
+        fs.appendFileSync(LOG_FILE, `[${new Date().toISOString()}] [Tools] ${msg}\n`);
+    }
+    catch { }
+}
+/**
+ * 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();
+    const config = loadConfig();
+    // === FREE UNIVERSE: Always injected ===
+    // Design tools
+    tools['gen_qrcode'] = genQrcodeTool;
+    tools['gen_diagram'] = genDiagramTool;
+    tools['gen_palette'] = genPaletteTool;
+    // Power tools
+    tools['file_to_url'] = fileToUrlTool;
+    tools['remove_background'] = removeBackgroundTool;
+    tools['extract_frames'] = extractFramesTool;
+    // gen_image (free version) — TODO Phase 4D
+    // tools['gen_image'] = genImageTool;
+    log(`Free tools injected: ${Object.keys(tools).length}`);
+    // === ENTER UNIVERSE: Only with valid API key ===
+    if (keyPresent) {
+        // Pollinations paid tools — TODO Phase 4D
+        // tools['gen_video'] = genVideoTool;
+        // tools['gen_audio'] = genAudioTool;
+        // tools['gen_music'] = genMusicTool;
+        // tools['deepsearch'] = deepsearchTool;
+        // tools['search_crawl_scrape'] = searchCrawlScrapeTool;
+        log(`Enter tools injected (key detected). Total: ${Object.keys(tools).length}`);
+    }
+    else {
+        log(`Enter tools SKIPPED (no key). Total: ${Object.keys(tools).length}`);
+    }
+    return tools;
+}

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;