opencode-pollinations-plugin 6.2.2 → 6.2.5

package/dist/server/generate-config.d.ts

@@ -12,6 +12,10 @@ interface OpenCodeModel {
         input?: string[];
         output?: string[];
     };
+    attachment?: boolean;
+    tool_call?: boolean;
+    reasoning?: boolean;
+    temperature?: boolean;
 }
 export declare function generatePollinationsConfig(forceApiKey?: string, forceStrict?: boolean): Promise<OpenCodeModel[]>;
 export {};

package/dist/server/generate-config.js

@@ -83,14 +83,13 @@ export async function generatePollinationsConfig(forceApiKey, forceStrict = fals
     if (effectiveKey && effectiveKey.length > 5 && effectiveKey !== 'dummy') {
         try {
             // Use /text/models for full metadata (input_modalities, tools, reasoning, pricing)
-            const enterListRaw = await fetchJson('https://gen.pollinations.ai/text/models', {
-                'Authorization': `Bearer ${effectiveKey}`
-            });
+            // We fetch WITHOUT the Authorization header because the authenticated API currently filters out some models
+            // like claude-airforce and step-3.5-flash. By fetching anonymously, we get the full list of 28 models.
+            const enterListRaw = await fetchJson('https://gen.pollinations.ai/text/models', {});
             const enterList = Array.isArray(enterListRaw) ? enterListRaw : (enterListRaw.data || []);
             const paidModels = [];
             enterList.forEach((m) => {
-                if (m.tools === false)
-                    return;
+                // All models exposed — no tool-based filtering
                 const mapped = mapModel(m, 'enter/', '');
                 modelsOutput.push(mapped);
                 if (m.paid_only) {
@@ -175,38 +174,68 @@ function mapModel(raw, prefix, namePrefix) {
     // Get capability icons from API metadata
     const capabilityIcons = getCapabilityIcons(raw);
     const finalName = `${paidPrefix}${baseName}${capabilityIcons}${freeSuffix}`;
+    // Context length: from API (dynamic), fallback 128K
+    const contextLength = raw.context_length || raw.context_window || 128000;
     const modelObj = {
         id: fullId,
         name: finalName,
         object: 'model',
         variants: {},
+        // Limits: context from API, output default 16384 (overridden per-model below)
+        limit: {
+            context: contextLength,
+            output: 16384
+        },
         // Declare modalities for OpenCode vision support
         modalities: {
             input: raw.input_modalities || ['text'],
             output: raw.output_modalities || ['text']
         }
     };
+    // --- CHAMPS DE CAPACITÉS REQUIS PAR OPENCODE (ModelsDev.Model schema) ---
+    const supportsVision = (raw.input_modalities && raw.input_modalities.includes('image')) || raw.vision === true;
+    modelObj.attachment = supportsVision; // Active le bouton d'attachement d'images dans l'IDE
+    modelObj.tool_call = raw.tools === true;
+    modelObj.reasoning = raw.reasoning === true;
+    modelObj.temperature = true; // Tous les modèles Pollinations supportent temperature
     // --- ENRICHISSEMENT ---
+    // 1. DÉTECTION ET CONFIGURATION DE LA VISION
+    // OpenCode uses attachment + modalities.input to determine vision support.
+    // No variant needed — a "chat" variant would OVERWRITE existing variants.
+    if (supportsVision) {
+        if (!modelObj.modalities.input.includes('image')) {
+            modelObj.modalities.input.push('image');
+        }
+    }
+    // 2. REASONING VARIANTS — format @ai-sdk/openai-compatible: { reasoningEffort: "level" }
     if (raw.reasoning === true || rawId.includes('thinking') || rawId.includes('reasoning')) {
-        modelObj.variants = { ...modelObj.variants, high_reasoning: { options: { reasoningEffort: "high", budgetTokens: 16000 } } };
+        modelObj.variants = {
+            ...modelObj.variants,
+            low: { reasoningEffort: 'low' },
+            high: { reasoningEffort: 'high' }
+        };
     }
-    if (rawId.includes('gemini') && !rawId.includes('fast')) {
-        if (!modelObj.variants.high_reasoning && (rawId === 'gemini' || rawId === 'gemini-large')) {
-            modelObj.variants.high_reasoning = { options: { reasoningEffort: "high", budgetTokens: 16000 } };
+    // Gemini models without explicit reasoning flag: add reasoning variants based on name
+    if (rawId.includes('gemini') && !rawId.includes('fast') && !modelObj.variants.high) {
+        if (rawId === 'gemini' || rawId === 'gemini-large') {
+            modelObj.variants = {
+                ...modelObj.variants,
+                low: { reasoningEffort: 'low' },
+                high: { reasoningEffort: 'high' }
+            };
         }
     }
+    // 3. SAFETY VARIANTS — maxTokens for models with known limits
     if (rawId.includes('claude') || rawId.includes('mistral') || rawId.includes('llama')) {
-        modelObj.variants.safe_tokens = { options: { maxTokens: 8000 } };
+        modelObj.variants.safe_tokens = { maxTokens: 8000 };
     }
     // NOVA FIX: Bedrock limit ~10k (User reported error > 10000)
-    // We MUST set the limit on the model object itself so OpenCode respects it by default.
     if (rawId.includes('nova')) {
         modelObj.limit = {
             output: 8000,
-            context: 128000 // Nova Micro/Lite/Pro usually 128k
+            context: 128000
         };
-        // Also keep variant just in case
-        modelObj.variants.bedrock_safe = { options: { maxTokens: 8000 } };
+        modelObj.variants.bedrock_safe = { maxTokens: 8000 };
     }
     // BEDROCK/ENTERPRISE LIMITS (Chickytutor only)
     if (rawId.includes('chickytutor')) {
@@ -216,16 +245,16 @@ function mapModel(raw, prefix, namePrefix) {
         };
     }
     // 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')) {
         modelObj.limit = {
-            output: 2048, // User used 1500 successfully
+            output: 2048,
             context: 32768
         };
     }
+    // 4. SPEED VARIANT — disable thinking for fast models
     if (rawId.includes('fast') || rawId.includes('flash') || rawId.includes('lite')) {
         if (!rawId.includes('gemini')) {
-            modelObj.variants.speed = { options: { thinking: { disabled: true } } };
+            modelObj.variants.speed = { thinking: { disabled: true } };
         }
     }
     return modelObj;

package/dist/server/models/fetcher.js

@@ -114,7 +114,9 @@ export async function fetchAllModels(apiKey) {
     const openapiPromise = fetchJson('https://enter.pollinations.ai/api/docs/open-api/generate-schema', headers).catch(() => ({}));
     const fetches = endpoints.map(async ({ url, fallbackCategory }) => {
         try {
-            const raw = await fetchJson(url, headers);
+            // Fetch model lists anonymously (no headers) to bypass API-side model filtering
+            // which currently hides models like claude-airforce to authenticated users.
+            const raw = await fetchJson(url, {});
             return { url, fallbackCategory, raw };
         }
         catch (e) {

package/dist/server/proxy.js

@@ -202,6 +202,38 @@ async function fetchWithRetry(url, options, retries = MAX_RETRIES) {
         throw error;
     }
 }
+// --- MEDIA UPLOAD HELPER (Vision Support) ---
+// Uploads a base64 data URL to media.pollinations.ai and returns a public URL.
+// This is needed because gen.pollinations.ai does not support OpenAI multimodal format
+// but auto-detects image URLs in plain text.
+async function uploadToPollinationsMedia(dataUrl, authHeader) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 15000);
+    try {
+        const res = await fetch('https://media.pollinations.ai/upload', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...(authHeader ? { 'Authorization': authHeader } : {}),
+            },
+            body: JSON.stringify({ data: dataUrl }),
+            signal: controller.signal,
+        });
+        if (!res.ok) {
+            const errText = await res.text().catch(() => '');
+            throw new Error(`HTTP ${res.status}: ${errText.substring(0, 100)}`);
+        }
+        const json = await res.json();
+        if (json.url)
+            return json.url;
+        if (json.id)
+            return `https://media.pollinations.ai/${json.id}`;
+        throw new Error('No URL in response');
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
 // --- MAIN HANDLER ---
 export async function handleChatCompletion(req, res, bodyRaw) {
     let targetUrl = '';
@@ -211,6 +243,21 @@ export async function handleChatCompletion(req, res, bodyRaw) {
         const config = loadConfig();
         // DEBUG: Trace Config State for Hot Reload verification
         log(`[Proxy Request] Config Loaded. Mode: ${config.mode}, HasKey: ${!!config.apiKey}, KeyLength: ${config.apiKey ? config.apiKey.length : 0}`);
+        // TEMPORARY DIAGNOSTIC: Capture multimodal content format from OpenCode
+        if (body.messages && body.messages.length > 0) {
+            const lastUserMsg = [...body.messages].reverse().find((m) => m.role === 'user');
+            if (lastUserMsg) {
+                const contentType = typeof lastUserMsg.content;
+                const isArray = Array.isArray(lastUserMsg.content);
+                log(`[VISION DEBUG] Last user msg content type: ${contentType}, isArray: ${isArray}`);
+                if (isArray) {
+                    log(`[VISION DEBUG] Content parts: ${JSON.stringify(lastUserMsg.content.map((c) => ({ type: c.type, hasText: !!c.text, hasImageUrl: !!c.image_url, hasImage: !!c.image })))}`);
+                }
+                else if (contentType === 'string') {
+                    log(`[VISION DEBUG] String content (first 200 chars): ${lastUserMsg.content.substring(0, 200)}`);
+                }
+            }
+        }
         // 0. COMMAND HANDLING
         if (body.messages && body.messages.length > 0) {
             const lastMsg = body.messages[body.messages.length - 1];
@@ -478,6 +525,12 @@ export async function handleChatCompletion(req, res, bodyRaw) {
             ...body,
             model: actualModel
         };
+        // === SECTION 2.1 — MULTIMODAL PASSTHROUGH ===
+        // The native OpenAI multimodal format [{type:"image_url",...}] is passed through as-is.
+        // Bug: Pollinations issue #8705 (opened 2026-03-01) — server does String(content)
+        // on array content, breaking vision. When fixed server-side, vision will work natively.
+        // The uploadToPollinationsMedia() helper is kept in stand-by for future fallback use.
+        // No transformation is applied — we send what OpenCode gives us.
         // 3. Global Hygiene
         if (!isEnterprise && !proxyBody.seed) {
             proxyBody.seed = Math.floor(Math.random() * 1000000);

package/package.json

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