opencode-pollinations-plugin 6.1.0-beta.9 → 6.2.0

package/dist/server/proxy.js

@@ -3,26 +3,22 @@ import * as path from 'path';
 import { loadConfig, saveConfig } from './config.js';
 import { handleCommand } from './commands.js';
 import { emitStatusToast, emitLogToast } from './toast.js';
+import { buildConnectResponse } from './connect-response.js';
+import { log } from './logger.js';
+import { getConfigDir } from './config.js';
+import { t } from '../locales/index.js';
 // --- PERSISTENCE: SIGNATURE MAP (Multi-Round Support) ---
-const SIG_FILE = path.join(process.env.HOME || '/tmp', '.config/opencode/pollinations-signature.json');
+const SIG_FILE = path.join(getConfigDir(), 'pollinations-signature.json');
 let signatureMap = {};
 let lastSignature = null; // V1 Fallback Global
-function log(msg) {
-    try {
-        const ts = new Date().toISOString();
-        if (!fs.existsSync('/tmp/opencode_pollinations_debug.log')) {
-            fs.writeFileSync('/tmp/opencode_pollinations_debug.log', '');
-        }
-        fs.appendFileSync('/tmp/opencode_pollinations_debug.log', `[Proxy] ${ts} ${msg}\n`);
-    }
-    catch (e) { }
-}
 try {
     if (fs.existsSync(SIG_FILE)) {
         signatureMap = JSON.parse(fs.readFileSync(SIG_FILE, 'utf-8'));
     }
 }
-catch (e) { }
+catch (e) {
+    log(`[Proxy Signature] Error loading: ${e}`);
+}
 function saveSignatureMap() {
     try {
         if (!fs.existsSync(path.dirname(SIG_FILE)))
@@ -78,6 +74,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 +99,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,141 +129,55 @@ function sanitizeToolsForVertex(tools) {
         return tool;
     });
 }
-function truncateTools(tools, limit = 120) {
-    if (!tools || tools.length <= limit)
-        return tools;
-    return tools.slice(0, limit);
-}
-// --- BEDROCK COMPATIBILITY SHIM ---
-// Bedrock requires: 
-// 1. toolUseId matching [a-zA-Z0-9_-]+ (no dots, spaces, special chars)
-// 2. toolConfig present when toolUse/toolResult in messages
-function sanitizeToolUseId(id) {
-    // Replace any char not in [a-zA-Z0-9_-] with underscore
-    return id.replace(/[^a-zA-Z0-9_-]/g, '_');
-}
-function sanitizeForBedrock(body) {
-    if (!body)
-        return body;
-    const sanitized = JSON.parse(JSON.stringify(body)); // Deep clone
-    // 1. Sanitize toolUseId in all messages AND detect tool history
-    let hasToolHistory = false;
-    const toolNamesFromHistory = [];
-    if (sanitized.messages && Array.isArray(sanitized.messages)) {
-        for (const msg of sanitized.messages) {
-            if (msg.content && Array.isArray(msg.content)) {
-                for (const block of msg.content) {
-                    // Handle toolUse blocks
-                    if (block.toolUse && block.toolUse.toolUseId) {
-                        block.toolUse.toolUseId = sanitizeToolUseId(block.toolUse.toolUseId);
-                        hasToolHistory = true;
-                        if (block.toolUse.name)
-                            toolNamesFromHistory.push(block.toolUse.name);
-                    }
-                    // Handle toolResult blocks
-                    if (block.toolResult && block.toolResult.toolUseId) {
-                        block.toolResult.toolUseId = sanitizeToolUseId(block.toolResult.toolUseId);
-                        hasToolHistory = true;
-                    }
-                    // Handle OpenAI-style tool_use in content array
-                    if (block.type === 'tool_use' && block.id) {
-                        block.id = sanitizeToolUseId(block.id);
-                        hasToolHistory = true;
-                        if (block.name)
-                            toolNamesFromHistory.push(block.name);
-                    }
-                }
-            }
-            // Handle assistant tool_calls array (OpenAI format)
-            if (msg.tool_calls && Array.isArray(msg.tool_calls)) {
-                hasToolHistory = true;
-                for (const tc of msg.tool_calls) {
-                    if (tc.id)
-                        tc.id = sanitizeToolUseId(tc.id);
-                    if (tc.function?.name)
-                        toolNamesFromHistory.push(tc.function.name);
-                }
-            }
-            // Handle tool role message (OpenAI format)
-            if (msg.role === 'tool') {
-                hasToolHistory = true;
-                if (msg.tool_call_id) {
-                    msg.tool_call_id = sanitizeToolUseId(msg.tool_call_id);
-                }
+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";
     }
-    // 2. Add toolConfig if tools present 
-    if (sanitized.tools && Array.isArray(sanitized.tools) && sanitized.tools.length > 0) {
-        if (!sanitized.tool_config && !sanitized.toolConfig) {
-            // Build toolConfig from tools array (Bedrock Converse format)
-            sanitized.tool_config = {
-                tools: sanitized.tools.map((t) => {
-                    if (t.function) {
-                        // OpenAI format -> Bedrock format
-                        return {
-                            toolSpec: {
-                                name: t.function.name,
-                                description: t.function.description || '',
-                                inputSchema: {
-                                    json: t.function.parameters || { type: 'object', properties: {} }
-                                }
-                            }
-                        };
-                    }
-                    return t; // Already in Bedrock format
-                })
-            };
+    if (schema.properties) {
+        for (const key in schema.properties) {
+            schema.properties[key] = sanitizeSchemaForKimi(schema.properties[key]);
         }
     }
-    // 3. CRITICAL: If no tools BUT history has tool calls, inject shim tools array
-    else if (hasToolHistory) {
-        // Bedrock requires toolConfig when history contains toolUse/toolResult
-        // Pollinations builds toolConfig from the 'tools' array, not from our 'tool_config'
-        // So we MUST inject 'tools' in OpenAI format, not just 'tool_config'
-        const uniqueToolNames = [...new Set(toolNamesFromHistory)];
-        // Build OpenAI-format tools array (this is what Pollinations actually uses!)
-        const shimTools = uniqueToolNames.length > 0
-            ? uniqueToolNames.map(name => ({
-                type: 'function',
-                function: {
-                    name: name,
-                    description: 'Tool inferred from conversation history (Bedrock compatibility shim)',
-                    parameters: { type: 'object', properties: {} }
-                }
-            }))
-            : [{
-                    type: 'function',
-                    function: {
-                        name: '_bedrock_shim_tool',
-                        description: 'Internal shim to satisfy Bedrock toolConfig requirement',
-                        parameters: { type: 'object', properties: {} }
-                    }
-                }];
-        // Inject the tools array (Pollinations format)
-        sanitized.tools = shimTools;
-        // Also set tool_config for direct Bedrock passthrough (belt & suspenders)
-        sanitized.tool_config = {
-            tools: shimTools.map(t => ({
-                toolSpec: {
-                    name: t.function.name,
-                    description: t.function.description,
-                    inputSchema: { json: t.function.parameters }
-                }
-            }))
-        };
-        log(`[Bedrock Shim] Injected ${shimTools.length} shim tool(s) for history compatibility: [${uniqueToolNames.join(', ') || '_bedrock_shim_tool'}]`);
-    }
-    return sanitized;
+    if (schema.items)
+        sanitizeSchemaForKimi(schema.items);
+    return schema;
+}
+function truncateTools(tools, limit = 120) {
+    if (!tools || tools.length <= limit)
+        return tools;
+    return tools.slice(0, limit);
 }
 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) {
@@ -275,11 +211,6 @@ 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}`);
-        // SPY LOGGING
-        try {
-            fs.appendFileSync('/tmp/opencode_spy.log', `\n\n=== REQUEST ${new Date().toISOString()} ===\nMODEL: ${body.model}\nBODY:\n${JSON.stringify(body, null, 2)}\n==========================\n`);
-        }
-        catch (e) { }
         // 0. COMMAND HANDLING
         if (body.messages && body.messages.length > 0) {
             const lastMsg = body.messages[body.messages.length - 1];
@@ -330,6 +261,31 @@ export async function handleChatCompletion(req, res, bodyRaw) {
             }
         }
         log(`Incoming Model (OpenCode ID): ${body.model}`);
+        // 0. SPECIAL: pollinations/connect (Guide & Status)
+        const CONNECT_MODEL_IDS = ['pollinations/connect', 'free/pollinations/connect', 'enter/pollinations/connect', 'connect-pollinations'];
+        if (CONNECT_MODEL_IDS.includes(body.model)) {
+            const guideContent = await buildConnectResponse(config);
+            res.writeHead(200, {
+                'Content-Type': 'text/event-stream',
+                'Cache-Control': 'no-cache',
+                'Connection': 'keep-alive'
+            });
+            const chunk = JSON.stringify({
+                id: 'connect-' + Date.now(),
+                object: 'chat.completion.chunk',
+                created: Math.floor(Date.now() / 1000),
+                model: 'pollinations/connect',
+                choices: [{
+                        index: 0,
+                        delta: { role: 'assistant', content: guideContent },
+                        finish_reason: 'stop' // Instant finish
+                    }]
+            });
+            res.write(`data: ${chunk}\n\n`);
+            res.write(`data: [DONE]\n\n`);
+            res.end();
+            return;
+        }
         // 1. STRICT ROUTING & SAFETY NET LOGIC (V5)
         let actualModel = body.model || "openai";
         let isEnterprise = false;
@@ -338,16 +294,15 @@ export async function handleChatCompletion(req, res, bodyRaw) {
         // LOAD QUOTA FOR SAFETY CHECKS
         const { getQuotaStatus, formatQuotaForToast } = await import('./quota.js');
         const quota = await getQuotaStatus(false);
-        // A. Resolve Base Target - v6.0: All models go to gen.pollinations.ai
-        // Strip any legacy prefixes for backwards compatibility
-        if (actualModel.startsWith('enter/') || actualModel.startsWith('enter-')) {
-            actualModel = actualModel.replace(/^enter[-/]/, '');
+        // A. Resolve Base Target
+        if (actualModel.startsWith('enter/')) {
+            isEnterprise = true;
+            actualModel = actualModel.replace('enter/', '');
         }
-        else if (actualModel.startsWith('free/') || actualModel.startsWith('free-')) {
-            actualModel = actualModel.replace(/^free[-/]/, '');
+        else if (actualModel.startsWith('free/')) {
+            isEnterprise = false;
+            actualModel = actualModel.replace('free/', '');
         }
-        // v6.0: Everything is enterprise now (requires API key)
-        isEnterprise = true;
         // A.1 PAID MODEL ENFORCEMENT (V5.5 Strategy)
         // Check dynamic list saved by generate-config.ts
         if (isEnterprise) {
@@ -367,8 +322,13 @@ export async function handleChatCompletion(req, res, bodyRaw) {
                         if (quota.walletBalance <= 0.001) { // Floating point safety
                             log(`[SafetyNet] Paid Only Model (${actualModel}) requested but Wallet is Empty ($${quota.walletBalance}). BLOCKING.`);
                             // Immediate Block or Fallback?
-                            // Fallback based on current mode
-                            actualModel = config.fallbacks.economy || 'nova-fast';
+                            // Text says: "💎 Paid Only models require purchased pollen only"
+                            // Blocking is safer/clearer than falling back to a free model which might not be what the user expects for a "Pro" feature?
+                            // Actually, Fallback to Free is usually better for UX if configured, BUT for specific "Paid Only" requests, the user explicitly chose a powerful model.
+                            // Falling back to Mistral might be confusing if they asked for Gemini-Large.
+                            // BUT we are failing gracefully.
+                            // Let's Fallback to Free Default and Warn.
+                            actualModel = config.fallbacks.free.main.replace('free/', '');
                             isEnterprise = false;
                             isFallbackActive = true;
                             fallbackReason = "Paid Only Model requires purchased credits";
@@ -394,127 +354,121 @@ export async function handleChatCompletion(req, res, bodyRaw) {
             // WE DO NOT RETURN 403. WE ALLOW THE REQUEST.
             // Since config.mode is now 'manual', the next checks (alwaysfree/pro) will be skipped.
         }
-        // === MODE ECONOMY ===
-        // - Paid models BLOCKED (not fallback, BLOCK with message)
-        // - tier < threshold → fallback economy
-        // - tier = 0 → STOP (no wallet access)
-        if (config.mode === 'economy') {
+        if (config.mode === 'alwaysfree') {
             if (isEnterprise) {
-                // 1. BLOCK Paid Models
+                // Paid Only Check: BLOCK (not fallback) in AlwaysFree mode
                 try {
                     const homedir = process.env.HOME || '/tmp';
                     const standardPaidPath = path.join(homedir, '.pollinations', 'pollinations-paid-models.json');
                     if (fs.existsSync(standardPaidPath)) {
                         const paidModels = JSON.parse(fs.readFileSync(standardPaidPath, 'utf-8'));
                         if (paidModels.includes(actualModel)) {
-                            log(`[Economy] BLOCKED: Paid model ${actualModel} not allowed in Economy mode`);
-                            emitStatusToast('error', `💎 Modèle payant interdit en mode Economy: ${actualModel}`, 'Mode Economy');
-                            res.writeHead(403, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({
-                                error: {
-                                    message: `💎 Paid model "${actualModel}" is not allowed in Economy mode. Switch to Pro mode or use a free model.`,
-                                    code: 'ECONOMY_PAID_BLOCKED'
-                                }
-                            }));
+                            log(`[AlwaysFree] BLOCKED: Paid Only Model (${actualModel}).`);
+                            emitStatusToast('warning', t('proxy.warnings.paid_blocked_alwaysfree_title', { model: actualModel }), 'AlwaysFree Mode');
+                            const blockMsg = {
+                                id: `chatcmpl-block-${Date.now()}`,
+                                object: 'chat.completion',
+                                created: Math.floor(Date.now() / 1000),
+                                model: actualModel,
+                                choices: [{
+                                        index: 0,
+                                        message: {
+                                            role: 'assistant',
+                                            content: t('proxy.warnings.paid_blocked_alwaysfree_msg', { model: actualModel })
+                                        },
+                                        finish_reason: 'stop'
+                                    }],
+                                usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
+                            };
+                            res.writeHead(200, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify(blockMsg));
                             return;
                         }
                     }
                 }
                 catch (e) {
-                    log(`[Economy] Error checking paid models: ${e}`);
+                    log(`[Proxy AlwaysFree] Error checking paid models: ${e}`);
                 }
-                // 2. Check Tier
-                if (quota.tier === 'error') {
-                    log(`[Economy] Quota unreachable, switching to fallback`);
-                    actualModel = config.fallbacks.economy || 'nova-fast';
+                if (!isFallbackActive && quota.tier === 'error') {
+                    // Network error or unknown error (but NOT auth_limited, handled above)
+                    log(`[SafetyNet] AlwaysFree Mode: Quota Check Failed. Switching to Free Fallback.`);
+                    emitStatusToast('warning', t('proxy.warnings.quota_unreachable_title'), 'AlwaysFree Mode');
+                    actualModel = config.fallbacks.free.main.replace('free/', '');
+                    isEnterprise = false;
                     isFallbackActive = true;
-                    fallbackReason = "Quota Unreachable (Safety)";
+                    fallbackReason = t('proxy.warnings.quota_unreachable_msg');
                 }
                 else {
                     const tierRatio = quota.tierLimit > 0 ? (quota.tierRemaining / quota.tierLimit) : 0;
-                    // 3. STOP if tier = 0
-                    if (quota.tierRemaining <= 0.01) {
-                        log(`[Economy] STOP: Tier exhausted, no wallet access in Economy mode`);
-                        emitStatusToast('error', `🛑 Quota épuisé! Attendez le reset ou passez en mode Pro.`, 'Mode Economy');
-                        res.writeHead(429, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({
-                            error: {
-                                message: `🛑 Daily quota exhausted. Wait for reset or switch to Pro mode to use wallet credits.`,
-                                code: 'ECONOMY_TIER_EXHAUSTED'
-                            }
-                        }));
-                        return;
-                    }
-                    // 4. Fallback if tier < threshold
                     if (tierRatio <= (config.thresholds.tier / 100)) {
-                        log(`[Economy] Tier ${(tierRatio * 100).toFixed(1)}% <= ${config.thresholds.tier}%, switching to fallback`);
-                        actualModel = config.fallbacks.economy || 'nova-fast';
+                        log(`[SafetyNet] AlwaysFree Mode: Tier (${(tierRatio * 100).toFixed(1)}%) <= Threshold (${config.thresholds.tier}%). Switching.`);
+                        emitStatusToast('warning', t('proxy.warnings.tier_limit_title', { threshold: config.thresholds.tier }), 'AlwaysFree Mode');
+                        actualModel = config.fallbacks.free.main.replace('free/', '');
+                        isEnterprise = false;
                         isFallbackActive = true;
-                        fallbackReason = `Tier < ${config.thresholds.tier}% (Economie active)`;
+                        fallbackReason = t('proxy.warnings.tier_limit_msg', { threshold: config.thresholds.tier });
                     }
                 }
             }
         }
-        // === MODE PRO ===
-        // - Paid models ALLOWED
-        // - wallet < wallet_stop $ → STOP
-        // - wallet < wallet_warn % → fallback pro
-        // - tier exhausted → info toast (continue on wallet)
         else if (config.mode === 'pro') {
             if (isEnterprise) {
-                // Init session wallet tracking (first request)
-                if (!config.session?.wallet_initial && quota.walletBalance > 0) {
-                    const { initSessionWallet } = await import('./config.js');
-                    initSessionWallet(quota.walletBalance);
-                }
                 if (quota.tier === 'error') {
-                    log(`[Pro] Quota unreachable, switching to fallback`);
-                    actualModel = config.fallbacks.pro || 'qwen-coder';
+                    // Network error or unknown
+                    log(`[SafetyNet] Pro Mode: Quota Unreachable. Switching to Free Fallback.`);
+                    emitStatusToast('warning', t('proxy.warnings.quota_unreachable_title'), 'Pro Mode');
+                    actualModel = config.fallbacks.free.main.replace('free/', '');
+                    isEnterprise = false;
                     isFallbackActive = true;
-                    fallbackReason = "Quota Unreachable (Safety)";
+                    fallbackReason = t('proxy.warnings.quota_unreachable_msg');
                 }
                 else {
-                    const walletStop = config.thresholds.wallet_stop || 0.50;
-                    const walletWarnPercent = config.thresholds.wallet_warn || 20;
-                    const walletInitial = config.session?.wallet_initial || quota.walletBalance;
-                    const walletPercent = walletInitial > 0 ? (quota.walletBalance / walletInitial) * 100 : 100;
-                    // 1. STOP if wallet < wallet_stop $
-                    if (quota.walletBalance < walletStop) {
-                        log(`[Pro] STOP: Wallet $${quota.walletBalance} < limit $${walletStop}`);
-                        emitStatusToast('error', `🛑 Wallet $${quota.walletBalance.toFixed(2)} sous limite $${walletStop}`, 'Mode Pro');
-                        res.writeHead(429, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({
-                            error: {
-                                message: `🛑 Wallet ($${quota.walletBalance.toFixed(2)}) below hard limit ($${walletStop}). Add credits or adjust wallet_stop threshold.`,
-                                code: 'PRO_WALLET_LIMIT'
-                            }
-                        }));
-                        return;
+                    const tierRatio = quota.tierLimit > 0 ? (quota.tierRemaining / quota.tierLimit) : 0;
+                    if (quota.walletBalance < config.thresholds.wallet && tierRatio <= (config.thresholds.tier / 100)) {
+                        log(`[SafetyNet] Pro Mode: Wallet < $${config.thresholds.wallet} AND Tier < ${config.thresholds.tier}%. Switching.`);
+                        emitStatusToast('warning', t('proxy.warnings.wallet_tier_critical_title', { wallet: config.thresholds.wallet, tier: config.thresholds.tier }), 'Pro Mode');
+                        actualModel = config.fallbacks.free.main.replace('free/', '');
+                        isEnterprise = false;
+                        isFallbackActive = true;
+                        fallbackReason = t('proxy.warnings.wallet_tier_critical_msg', { wallet: config.thresholds.wallet, tier: config.thresholds.tier });
                     }
-                    // 2. Fallback if wallet% < wallet_warn%
-                    if (walletPercent <= walletWarnPercent) {
-                        log(`[Pro] Wallet ${walletPercent.toFixed(1)}% <= ${walletWarnPercent}%, switching to fallback`);
-                        actualModel = config.fallbacks.pro || 'qwen-coder';
+                    else if (quota.walletBalance < config.thresholds.wallet) {
+                        log(`[SafetyNet] Pro Mode: Wallet < $${config.thresholds.wallet}. Switching.`);
+                        emitStatusToast('warning', t('proxy.warnings.wallet_limit_title', { wallet: config.thresholds.wallet }), 'Pro Mode');
+                        actualModel = config.fallbacks.free.main.replace('free/', '');
+                        isEnterprise = false;
                         isFallbackActive = true;
-                        fallbackReason = `Wallet < ${walletWarnPercent}% (${quota.walletBalance.toFixed(2)}$)`;
+                        fallbackReason = t('proxy.warnings.wallet_limit_msg', { threshold: config.thresholds.wallet });
                     }
-                    // 3. Info if tier exhausted (continue on wallet)
-                    if (quota.tierRemaining <= 0.01 && !isFallbackActive) {
-                        emitStatusToast('info', `ℹ️ Tier épuisé, utilisation du wallet ($${quota.walletBalance.toFixed(2)})`, 'Mode Pro');
+                    else if (tierRatio <= (config.thresholds.tier / 100)) {
+                        log(`[SafetyNet] Pro Mode: Tier < ${config.thresholds.tier}%. Switching.`);
+                        emitStatusToast('warning', t('proxy.warnings.tier_limit_title', { threshold: config.thresholds.tier }), 'Pro Mode');
+                        actualModel = config.fallbacks.free.main.replace('free/', '');
+                        isEnterprise = false;
+                        isFallbackActive = true;
+                        fallbackReason = t('proxy.warnings.tier_limit_msg', { threshold: config.thresholds.tier });
                     }
                 }
             }
         }
-        // C. Construct URL & Headers - v6.0: Always gen.pollinations.ai
-        if (!config.apiKey) {
-            emitLogToast('error', "Missing API Key - Use /pollinations connect <key>", 'Proxy Error');
-            res.writeHead(401, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: { message: "API Key required. Use /pollinations connect <your_key> to connect." } }));
-            return;
+        // C. Construct URL & Headers
+        if (isEnterprise) {
+            if (!config.apiKey) {
+                emitLogToast('error', "Missing API Key for Enterprise Model", 'Proxy Error');
+                res.writeHead(401, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: { message: "API Key required for Enterprise models." } }));
+                return;
+            }
+            targetUrl = 'https://gen.pollinations.ai/v1/chat/completions';
+            authHeader = `Bearer ${config.apiKey}`;
+            log(`Routing to ENTERPRISE: ${actualModel}`);
+        }
+        else {
+            targetUrl = 'https://text.pollinations.ai/openai/chat/completions';
+            authHeader = undefined;
+            log(`Routing to FREE: ${actualModel} ${isFallbackActive ? '(FALLBACK)' : ''}`);
+            // emitLogToast('info', `Routing to: FREE UNIVERSE (${actualModel})`, 'Pollinations Routing'); // Too noisy
         }
-        targetUrl = 'https://gen.pollinations.ai/v1/chat/completions';
-        authHeader = `Bearer ${config.apiKey}`;
-        log(`Routing to gen.pollinations.ai: ${actualModel}`);
         // NOTIFY SWITCH
         if (isFallbackActive) {
             emitStatusToast('warning', `⚠️ Safety Net: ${actualModel} (${fallbackReason})`, 'Pollinations Safety');
@@ -546,17 +500,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) {
@@ -571,6 +532,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 } };
@@ -578,36 +544,12 @@ 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.
-            // GLOBAL BEDROCK FIX (All Models)
-            // Check if history has tools but current request misses tools definition.
-            // This happens when OpenCode sends the Tool Result (optimisation),
-            // but Bedrock requires toolConfig to validate the history.
-            const hasToolHistory = proxyBody.messages?.some((m) => m.role === 'tool' || m.tool_calls);
-            if (hasToolHistory && (!proxyBody.tools || proxyBody.tools.length === 0)) {
-                // Inject Shim Tool to satisfy Bedrock
-                proxyBody.tools = [{
-                        type: 'function',
-                        function: {
-                            name: '_bedrock_compatibility_shim',
-                            description: 'Internal system tool to satisfy Bedrock strict toolConfig requirement. Do not use.',
-                            parameters: { type: 'object', properties: {} }
-                        }
-                    }];
-                log(`[Proxy] Bedrock Fix: Injected shim tool for ${actualModel} (History has tools, Request missing tools)`);
-            }
-            // B. GEMINI UNIFIED FIX (Free, Fast, Pro, Enterprise, Legacy)
-            // Fixes "Multiple tools" error (Vertex) and "JSON body validation failed" (v5.3.5 regression)
-            // Added ChickyTutor (Claude/Gemini based) to fix "toolConfig must be defined" error.
-            else if (actualModel.includes("gemini") || actualModel.includes("chickytutor")) {
+            else if (actualModel.includes("gemini")) {
                 let hasFunctions = false;
                 if (proxyBody.tools && Array.isArray(proxyBody.tools)) {
                     hasFunctions = proxyBody.tools.some((t) => t.type === 'function' || t.function);
                 }
-                // Old Shim logic removed (moved up)
                 if (hasFunctions) {
                     // 1. Strict cleanup of 'google_search' tool
                     proxyBody.tools = proxyBody.tools.filter((t) => {
@@ -638,14 +580,6 @@ export async function handleChatCompletion(req, res, bodyRaw) {
                 log(`[Proxy] Gemini Logic: Tools=${proxyBody.tools ? proxyBody.tools.length : 'REMOVED'}, Stops NOT Injected.`);
             }
         }
-        // B5. BEDROCK TOKEN LIMIT FIX
-        if (actualModel.includes("chicky") || actualModel.includes("mistral")) {
-            // Force max_tokens if not present or too high (Bedrock outputs usually max 4k, context 8k+ but strict check)
-            if (!proxyBody.max_tokens || proxyBody.max_tokens > 4096) {
-                proxyBody.max_tokens = 4096;
-                log(`[Proxy] Enforcing max_tokens=4096 for ${actualModel} (Bedrock Limit)`);
-            }
-        }
         // C. GEMINI ID BACKTRACKING & SIGNATURE
         if ((actualModel.includes("gemini") || actualModel === "nomnom") && proxyBody.messages) {
             const lastMsg = proxyBody.messages[proxyBody.messages.length - 1];
@@ -709,18 +643,10 @@ export async function handleChatCompletion(req, res, bodyRaw) {
         if (authHeader)
             headers['Authorization'] = authHeader;
         // 5. Forward (Global Fetch with Retry)
-        // BEDROCK COMPATIBILITY: Apply transformation BEFORE first request
-        const isBedrockModel = actualModel.includes('nova') ||
-            actualModel.includes('amazon') ||
-            actualModel.includes('chickytutor');
-        const finalProxyBody = isBedrockModel ? sanitizeForBedrock(proxyBody) : proxyBody;
-        if (isBedrockModel) {
-            log(`[Proxy] Applied Bedrock shim for ${actualModel} (Initial Request)`);
-        }
         const fetchRes = await fetchWithRetry(targetUrl, {
             method: 'POST',
             headers: headers,
-            body: JSON.stringify(finalProxyBody)
+            body: JSON.stringify(proxyBody)
         });
         res.statusCode = fetchRes.status;
         fetchRes.headers.forEach((val, key) => {
@@ -739,14 +665,20 @@ export async function handleChatCompletion(req, res, bodyRaw) {
             if ((isEnterpriseFallback || isGeminiToolsFallback) && config.mode !== 'manual') {
                 log(`[SafetyNet] Upstream Rejection (${fetchRes.status}). Triggering Transparent Fallback.`);
                 if (isEnterpriseFallback) {
-                    // 1a. Enterprise -> Fallback based on mode
-                    actualModel = config.mode === 'pro'
-                        ? (config.fallbacks.pro || 'qwen-coder')
-                        : (config.fallbacks.economy || 'nova-fast');
+                    // 1a. Enterprise -> Free Fallback
+                    actualModel = config.fallbacks.free.main.replace('free/', '');
                     isEnterprise = false;
                     isFallbackActive = true;
-                    if (fetchRes.status === 402)
+                    if (fetchRes.status === 402) {
                         fallbackReason = "Insufficient Funds (Upstream 402)";
+                        // Force refresh quota cache so next pre-flight check is accurate
+                        try {
+                            await getQuotaStatus(true);
+                        }
+                        catch (e) {
+                            log(`[Proxy Quota] Silent refresh error: ${e}`);
+                        }
+                    }
                     else if (fetchRes.status === 429)
                         fallbackReason = "Rate Limit (Upstream 429)";
                     else if (fetchRes.status === 401)
@@ -764,33 +696,16 @@ export async function handleChatCompletion(req, res, bodyRaw) {
                 // 2. Notify
                 emitStatusToast('warning', `⚠️ Safety Net: ${actualModel} (${fallbackReason})`, 'Pollinations Safety');
                 emitLogToast('warning', `Recovering from ${fetchRes.status} -> Switching to ${actualModel}`, 'Safety Net');
-                // 3. Re-Prepare Request - v6.0: Stay on gen.pollinations.ai
-                targetUrl = 'https://gen.pollinations.ai/v1/chat/completions';
+                // 3. Re-Prepare Request
+                targetUrl = 'https://text.pollinations.ai/openai/chat/completions';
                 const retryHeaders = { ...headers };
-                // Keep Authorization for gen.pollinations.ai
+                delete retryHeaders['Authorization']; // Free = No Auth
                 const retryBody = { ...proxyBody, model: actualModel };
-                // LIMIT MAX_TOKENS for lightweight fallback models (e.g. nova-fast limits)
-                if (actualModel.includes('nova') || actualModel.includes('fast')) {
-                    // Force max_tokens down if missing or too high
-                    if (!retryBody.max_tokens || retryBody.max_tokens > 4000) {
-                        retryBody.max_tokens = 4000;
-                        log(`[SafetyNet] Adjusted max_tokens to 4000 for ${actualModel}`);
-                    }
-                }
-                // BEDROCK COMPATIBILITY SHIM (BUG 1 - Proper Transform)
-                const isBedrockModel = actualModel.includes('nova') ||
-                    actualModel.includes('amazon') ||
-                    actualModel.includes('chickytutor');
-                let finalRetryBody = retryBody;
-                if (isBedrockModel) {
-                    finalRetryBody = sanitizeForBedrock(retryBody);
-                    log(`[SafetyNet] Applied Bedrock shim for ${actualModel}`);
-                }
                 // 4. Retry Fetch
                 const retryRes = await fetchWithRetry(targetUrl, {
                     method: 'POST',
                     headers: retryHeaders,
-                    body: JSON.stringify(finalRetryBody)
+                    body: JSON.stringify(retryBody)
                 });
                 if (retryRes.ok) {
                     res.statusCode = retryRes.status;