@paytaca/opencode-plugin 0.2.2 → 0.3.1

package/dist/bundled/proxy.js

@@ -64,7 +64,7 @@ let requestCounter = 0;
 // Utility: run shell command and return output
 function runCommand(cmd, args = []) {
   return new Promise((resolve, reject) => {
-    const child = spawn(cmd, args, { shell: false });
+    const child = spawn(cmd, args, { shell: process.platform === 'win32' });
     let stdout = '';
     let stderr = '';
     
@@ -110,6 +110,60 @@ async function getWalletBalance() {
   }
 }
 
+// LIFT token balance in base units (2 decimals); null when unavailable.
+const LIFT_TOKEN_ID = '5932b2fd4915d6a75d3ec53282cd49118149a2176ee67ed68b1111ff0786f7fc';
+async function getLiftBalance() {
+  try {
+    const output = await runCommand(PAYTACA_CMD, ['token', 'info', LIFT_TOKEN_ID]);
+    const match = output.match(/Balance:\s*([\d.]+)\s*LIFT/i);
+    if (match) return Math.round(parseFloat(match[1]) * 100);
+    return null;
+  } catch (err) {
+    log('Failed to get LIFT balance: ' + err.message);
+    return null;
+  }
+}
+
+// Short-lived cache of wallet + LIFT balances so we don't shell out to the CLI
+// on every forwarded prompt. The backend concierge reads these headers to give
+// free balance answers when the wallet has no paid capacity.
+const BALANCE_CACHE_TTL = 15000;
+let balanceCache = { at: 0, sats: null, lift: null };
+
+async function getCachedBalances() {
+  const now = Date.now();
+  if (balanceCache.at && now - balanceCache.at < BALANCE_CACHE_TTL) {
+    return { sats: balanceCache.sats, lift: balanceCache.lift };
+  }
+  const sats = await getWalletBalance();
+  const lift = await getLiftBalance();
+  balanceCache = { at: now, sats, lift };
+  return { sats, lift };
+}
+
+// LIFT payment discount percent advertised by the backend (/v1/config), cached
+// briefly (30s) so a server-side rate change is picked up quickly. Returns 0
+// when unset/unavailable so callers can fall back to no-discount messaging.
+let liftDiscountCache = { at: 0, percent: 0 };
+async function getLiftDiscountPercent() {
+  const now = Date.now();
+  if (liftDiscountCache.at && now - liftDiscountCache.at < 30000) {
+    return liftDiscountCache.percent;
+  }
+  let percent = 0;
+  try {
+    const configRes = await fetch(BACKEND_URL + '/v1/config');
+    if (configRes.ok) {
+      const data = await configRes.json();
+      percent = Number(data.lift_payment_discount_percent) || 0;
+    }
+  } catch (err) {
+    log('Failed to fetch LIFT discount config: ' + err.message);
+  }
+  liftDiscountCache = { at: now, percent };
+  return percent;
+}
+
 // Utility: get receiving address
 async function getReceivingAddress() {
   try {
@@ -255,10 +309,20 @@ async function streamTierSelectionBody(res, walletHash, modelName, tiers, includ
     choices: [{ index: 0, delta: { content: tiersContent }, finish_reason: null }],
   });
 
+  // Advertise the LIFT discount when the backend advertises one.
+  const liftPercent = await getLiftDiscountPercent();
+  if (liftPercent > 0) {
+    sseLine(res, {
+      id: 'tier-10b',
+      object: 'chat.completion.chunk',
+      choices: [{ index: 0, delta: { content: '\\n💡 **' + liftPercent + '% off** when you pay with LIFT tokens — type \`LIFT\` to pay with LIFT and get the discount.\\n' }, finish_reason: null }],
+    });
+  }
+
   sseLine(res, {
     id: 'tier-11',
     object: 'chat.completion.chunk',
-    choices: [{ index: 0, delta: { content: '\\nEnter a number (1-' + tiers.length + '), e.g. type ' + tiers[0].minutes + ':\\n' }, finish_reason: 'stop' }],
+    choices: [{ index: 0, delta: { content: '\\nEnter a number (1-' + tiers.length + ') to pay with BCH, or type \`LIFT\` to pay with LIFT tokens' + (liftPercent > 0 ? ' and get ' + liftPercent + '% off' : '') + ':\\n' }, finish_reason: 'stop' }],
   });
 
   // If other models still have paid credits, tell the user they can switch
@@ -334,7 +398,8 @@ async function streamLowBalanceNotice(res, modelName, otherModels) {
 }
 
 // Forward request to Django and return response (buffered, for non-streaming)
-function forwardToDjango(req, body, callback) {
+async function forwardToDjango(req, body, callback) {
+  const balances = await getCachedBalances();
   const options = {
     hostname: DJANGO_HOST,
     port: DJANGO_PORT,
@@ -343,6 +408,8 @@ function forwardToDjango(req, body, callback) {
     headers: {
       'Content-Type': req.headers['content-type'] || 'application/json',
       'X-Wallet-Hash': req.headers['x-wallet-hash'] || '',
+      'X-Wallet-Balance-Sats': balances.sats !== null ? String(balances.sats) : '',
+      'X-Lift-Balance-Units': balances.lift !== null ? String(balances.lift) : '',
       'Content-Length': Buffer.byteLength(body),
     },
   };
@@ -386,7 +453,8 @@ function forwardToDjango(req, body, callback) {
 }
 
 // Forward streaming request to Django
-function forwardStreaming(req, res, body, callback) {
+async function forwardStreaming(req, res, body, callback) {
+  const balances = await getCachedBalances();
   const options = {
     hostname: DJANGO_HOST,
     port: DJANGO_PORT,
@@ -395,6 +463,8 @@ function forwardStreaming(req, res, body, callback) {
     headers: {
       'Content-Type': req.headers['content-type'] || 'application/json',
       'X-Wallet-Hash': req.headers['x-wallet-hash'] || '',
+      'X-Wallet-Balance-Sats': balances.sats !== null ? String(balances.sats) : '',
+      'X-Lift-Balance-Units': balances.lift !== null ? String(balances.lift) : '',
       'Content-Length': Buffer.byteLength(body),
     },
   };
@@ -731,7 +801,7 @@ async function streamPaymentFailureAndRetry(res, walletHash, pendingPayload, mes
 }
 
 // Run paytaca pay internally and return the response
-function runPaytacaPay(djangoUrl, body, walletHash, extraHeaders, callback) {
+function runPaytacaPay(djangoUrl, body, walletHash, extraHeaders, paymentMethod, callback) {
   const url = djangoUrl + '/chat/completions?wallet_hash=' + encodeURIComponent(walletHash || '');
   const payBody = forceNonStreaming(body);
 
@@ -753,6 +823,9 @@ function runPaytacaPay(djangoUrl, body, walletHash, extraHeaders, callback) {
     bodyFile,
     confirmed: true,
   };
+  if (paymentMethod === 'lift') {
+    config.paymentMethod = 'lift';
+  }
 
   try {
     fs.writeFileSync(configFile, JSON.stringify(config), 'utf8');
@@ -816,6 +889,184 @@ function runPaytacaPay(djangoUrl, body, walletHash, extraHeaders, callback) {
   });
 }
 
+// ---------------------------------------------------------------------------
+// Auto-refill: when armed via the MCP auto_refill tool, the proxy silently buys
+// a plan of the configured size on 402 (credits exhausted) and retries instead
+// of showing the interactive tier prompt. It stops when the cumulative budget
+// (maxMinutes) is reached, the requested model mismatches, funds are short, or
+// 24h pass without a refill (so a stale armed state cannot keep spending in a
+// later session).
+const AUTO_REFILL_FILE = path.join(LOG_DIR, 'auto-refill.json');
+
+function getAutoRefillState() {
+  try {
+    const s = JSON.parse(fs.readFileSync(AUTO_REFILL_FILE, 'utf8'));
+    if (!s || s.enabled !== true) {
+      return null;
+    }
+    return {
+      enabled: true,
+      minutes: Number(s.minutes) || 0,
+      maxMinutes: Number(s.maxMinutes) || 0,
+      spentMinutes: Number(s.spentMinutes) || 0,
+      model: s.model ? String(s.model) : '',
+      paymentMethod: s.paymentMethod === 'lift' ? 'lift' : 'bch',
+      startedAt: s.startedAt || new Date().toISOString(),
+      lastRefillAt: s.lastRefillAt || null,
+    };
+  } catch (err) {
+    log('Failed to read auto-refill state: ' + err.message);
+    return null;
+  }
+}
+
+function saveAutoRefillState(s) {
+  try {
+    fs.writeFileSync(AUTO_REFILL_FILE, JSON.stringify(s, null, 2), 'utf8');
+  } catch (err) {
+    log('Failed to write auto-refill state: ' + err.message);
+  }
+}
+
+// Can the proxy buy another plan right now? Handles budget, model scope and a
+// staleness rule — when it returns false the caller falls through to the normal
+// interactive tier prompt so the user can buy manually.
+function autoRefillCanBuy(s, modelId) {
+  if (!s || !s.enabled) return false;
+  if (s.minutes <= 0 || s.maxMinutes < s.minutes) {
+    log('Auto-refill disarmed: bad config (minutes=' + s.minutes + ' maxMinutes=' + s.maxMinutes + ')');
+    s.enabled = false;
+    saveAutoRefillState(s);
+    return false;
+  }
+  if (s.spentMinutes >= s.maxMinutes) {
+    return false;
+  }
+  if (s.model && (!modelId || s.model !== modelId)) {
+    return false;
+  }
+  const now = Date.now();
+  const anchorMs = new Date(s.lastRefillAt || s.startedAt || now).getTime();
+  if (isNaN(anchorMs) || now - anchorMs > 24 * 3600 * 1000) {
+    log('Auto-refill disarmed: stale (no refill for 24h)');
+    s.enabled = false;
+    saveAutoRefillState(s);
+    return false;
+  }
+  return true;
+}
+
+// Buy the configured plan automatically and retry the request. Mirrors the
+// interactive payment path (keepalive + paytaca pay + SSE delivery) but never
+// asks the user to pick a tier. On failure it disarms auto-refill and streams
+// the payment-error prompt so the user can retry by hand.
+async function autoRefillAndRetry(res, walletHash, pendingPayload, refill) {
+  log('AUTO-REFILL: buying ' + refill.minutes + '-min plan for wallet ' + walletHash?.substring(0, 16) + '...');
+  pendingPayload.step = 'processing';
+  const extraHeaders = {};
+  if (pendingPayload.modelId) {
+    extraHeaders['X-Model-Id'] = pendingPayload.modelId;
+  }
+  extraHeaders['X-Duration-Minutes'] = String(refill.minutes);
+  if (refill.paymentMethod === 'lift') {
+    extraHeaders['X-Payment-Method'] = 'lift';
+  }
+
+  if (!res.headersSent) {
+    try {
+      res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+        'X-Payment-Processing': 'true',
+      });
+    } catch (e) {
+      log('autoRefillAndRetry writeHead failed: ' + e.message);
+    }
+  }
+  const keepalive = setInterval(() => {
+    if (res.destroyed || res.writableEnded) { clearInterval(keepalive); return; }
+    res.write(': keepalive\\n\\n');
+  }, 2000);
+
+  runPaytacaPay(BACKEND_URL + '/v1', pendingPayload.body, walletHash, extraHeaders, refill.paymentMethod || 'bch', async (err, responseJson) => {
+    clearInterval(keepalive);
+    pendingPayments.delete(walletHash);
+
+    const disarmAndFail = async (msg) => {
+      refill.enabled = false;
+      saveAutoRefillState(refill);
+      log('AUTO-REFILL: failed (' + msg + ') — disarmed');
+      if (res.headersSent && !res.destroyed && !res.writableEnded) {
+        await streamPaymentFailureAndRetry(res, walletHash, pendingPayload, '\\n\\n❌ Auto-refill payment failed: ' + msg + '\\n\\n');
+      } else if (!res.headersSent) {
+        try {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'Payment failed', message: msg }));
+        } catch (e) { log('Failed to write auto-refill error JSON: ' + e.message); }
+      } else {
+        log('Cannot send auto-refill failure — response already ended or destroyed');
+      }
+    };
+
+    if (err) {
+      return await disarmAndFail(err.message);
+    }
+    if (!responseJson.success) {
+      const msg = responseJson.timeout
+        ? 'response timed out after payment — check credits with \\'credits\\' and retry'
+        : (responseJson.error || 'Unknown payment error');
+      return await disarmAndFail(msg);
+    }
+
+    // Payment succeeded — count it toward the budget.
+    const spent = Math.min(refill.spentMinutes + refill.minutes, refill.maxMinutes);
+    const exhausted = spent >= refill.maxMinutes;
+    refill.spentMinutes = spent;
+    refill.lastRefillAt = new Date().toISOString();
+    if (exhausted) {
+      refill.enabled = false;
+    }
+    saveAutoRefillState(refill);
+
+    const chatCompletion = responseJson?.data || responseJson;
+    let wasStreaming = false;
+    try {
+      wasStreaming = JSON.parse(pendingPayload.body).stream === true;
+    } catch (e) {}
+
+    log('AUTO-REFILL: payment ok, spent=' + spent + ' min, exhausted=' + exhausted);
+
+    if (res.destroyed || res.writableEnded) {
+      log('Auto-refill payment succeeded but response connection is gone — cannot deliver chat response');
+      return;
+    }
+
+    let note = '⚡ Auto-refill active: bought a ' + refill.minutes + '-minute plan for ' + (pendingPayload.displayName || pendingPayload.modelId || 'this model') + ' (' + spent + '/' + refill.maxMinutes + ' min budget used)';
+    if (exhausted) {
+      note += ' — **budget reached, auto-refill is now OFF**. Reply to buy more manually if you need to keep going.';
+    }
+    note += '. Generating your response...\\n\\n';
+
+    if (wasStreaming) {
+      try {
+        jsonToSse(res, chatCompletion, { prependContent: PROXY_MARKER + '\\n' + note });
+      } catch (e) {
+        log('auto-refill jsonToSse threw: ' + e.message);
+      }
+    } else {
+      try {
+        if (!res.headersSent) {
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+        }
+        res.end(JSON.stringify(chatCompletion));
+      } catch (e) {
+        log('auto-refill non-stream send failed: ' + e.message);
+      }
+    }
+  });
+}
+
 // Extract the last user message content from a chat payload
 function getLastUserMessageContent(body) {
   try {
@@ -1167,20 +1418,43 @@ const server = http.createServer(async (req, res) => {
             await handlePricingCommand(res);
             return;
           }
+
+          // LIFT payment option: user typed "LIFT" (optionally followed by a
+          // tier number, e.g. "LIFT 2"). Defaults to the first tier.
+          let paymentMethod = 'bch';
+          if (timeCmd === 'lift' || (timeCmd && /^lift[\s]+\\d+$/.test(timeCmd))) {
+            paymentMethod = 'lift';
+          }
+          let liftTierIndex = -1;
+          if (timeCmd && /^lift[\s]+\\d+$/.test(timeCmd)) {
+            const liftNum = parseInt(timeCmd.split(/\\s+/)[1], 10);
+            if (!isNaN(liftNum) && liftNum >= 1 && liftNum <= pendingPayload.tiers.length) {
+              liftTierIndex = liftNum - 1;
+            }
+          }
+
           let selectedIndex = -1;
           
-          // Try to parse user input as a number (1-based)
-          const num = parseInt(userInput, 10);
-          if (!isNaN(num) && num >= 1 && num <= pendingPayload.tiers.length) {
-            selectedIndex = num - 1;
+          // "LIFT" alone selects the first (cheapest) tier paid with LIFT;
+          // "LIFT N" selects tier N.
+          if (paymentMethod === 'lift' && liftTierIndex >= 0) {
+            selectedIndex = liftTierIndex;
+          } else if (paymentMethod === 'lift') {
+            selectedIndex = 0;
           } else {
-            // Try to match by duration minutes
-            for (let i = 0; i < pendingPayload.tiers.length; i++) {
-              if (userInput === String(pendingPayload.tiers[i].minutes) ||
-                  userInput === pendingPayload.tiers[i].minutes + ' minutes' ||
-                  userInput === pendingPayload.tiers[i].minutes + ' min') {
-                selectedIndex = i;
-                break;
+            // Try to parse user input as a number (1-based)
+            const num = parseInt(userInput, 10);
+            if (!isNaN(num) && num >= 1 && num <= pendingPayload.tiers.length) {
+              selectedIndex = num - 1;
+            } else {
+              // Try to match by duration minutes
+              for (let i = 0; i < pendingPayload.tiers.length; i++) {
+                if (userInput === String(pendingPayload.tiers[i].minutes) ||
+                    userInput === pendingPayload.tiers[i].minutes + ' minutes' ||
+                    userInput === pendingPayload.tiers[i].minutes + ' min') {
+                  selectedIndex = i;
+                  break;
+                }
               }
             }
           }
@@ -1188,9 +1462,10 @@ const server = http.createServer(async (req, res) => {
           if (selectedIndex >= 0) {
             const selectedTier = pendingPayload.tiers[selectedIndex];
             pendingPayload.durationMinutes = selectedTier.minutes;
+            pendingPayload.paymentMethod = paymentMethod;
             pendingPayload.step = 'processing';
             
-            log('Tier selected: ' + selectedTier.minutes + ' min for wallet ' + walletHash?.substring(0, 16) + '...');
+            log('Tier selected: ' + selectedTier.minutes + ' min (' + paymentMethod + ') for wallet ' + walletHash?.substring(0, 16) + '...');
             
             // Build extra headers for payment wrapper
             const extraHeaders = {};
@@ -1198,28 +1473,56 @@ const server = http.createServer(async (req, res) => {
               extraHeaders['X-Model-Id'] = pendingPayload.modelId;
             }
             extraHeaders['X-Duration-Minutes'] = String(selectedTier.minutes);
+            if (paymentMethod === 'lift') {
+              extraHeaders['X-Payment-Method'] = 'lift';
+            }
             
-            // Check wallet balance before attempting payment
-            const currentBalanceSats = await getWalletBalance();
-            if (currentBalanceSats !== null && selectedTier.price_sats && currentBalanceSats < selectedTier.price_sats) {
-              log('Insufficient balance for wallet ' + walletHash?.substring(0, 16) + '...: ' + currentBalanceSats + ' sats < ' + selectedTier.price_sats + ' sats needed');
-              pendingPayments.delete(walletHash);
-              const addr = await getReceivingAddress();
-              const neededBch = (selectedTier.price_sats - currentBalanceSats) / 100000000;
-              const neededLine = addr ? '\\n\\n📥 **Fund your wallet:** \\\`' + addr + '\\\`\\nOr run: paytaca receive (in another terminal) for QR code' : '';
-              sseLine(res, {
-                id: 'balance-err',
-                object: 'chat.completion.chunk',
-                choices: [{ index: 0, delta: { content: PROXY_MARKER + '\\n\\n❌ **Insufficient balance** — You have **' + (currentBalanceSats / 100000000).toFixed(8) + ' BCH** but need **' + (selectedTier.price_sats / 100000000).toFixed(8) + ' BCH** for this plan. Top up at least **' + neededBch.toFixed(8) + ' BCH** more.' + neededLine + '\\n\\nType \\\`balance\\\` to re-check or try a different plan:' }, finish_reason: 'stop' }],
-              });
-              sseLine(res, {
-                id: 'balance-err-done',
-                object: 'chat.completion.chunk',
-                choices: [{ index: 0, delta: {}, finish_reason: 'stop' }],
-              });
-              sseDone(res);
-              res.end();
-              return;
+            // Check wallet balance before attempting payment — only for BCH.
+            // The LIFT path sells tokens, so no BCH balance is required.
+            if (paymentMethod !== 'lift') {
+              const currentBalanceSats = await getWalletBalance();
+              if (currentBalanceSats !== null && selectedTier.price_sats && currentBalanceSats < selectedTier.price_sats) {
+                log('Insufficient balance for wallet ' + walletHash?.substring(0, 16) + '...: ' + currentBalanceSats + ' sats < ' + selectedTier.price_sats + ' sats needed');
+                pendingPayments.delete(walletHash);
+                const addr = await getReceivingAddress();
+                const neededBch = (selectedTier.price_sats - currentBalanceSats) / 100000000;
+                const neededLine = addr ? '\\n\\n📥 **Fund your wallet:** \\\`' + addr + '\\\`\\nOr run: paytaca receive (in another terminal) for QR code' : '';
+                sseLine(res, {
+                  id: 'balance-err',
+                  object: 'chat.completion.chunk',
+                  choices: [{ index: 0, delta: { content: PROXY_MARKER + '\\n\\n❌ **Insufficient balance** — You have **' + (currentBalanceSats / 100000000).toFixed(8) + ' BCH** but need **' + (selectedTier.price_sats / 100000000).toFixed(8) + ' BCH** for this plan. Top up at least **' + neededBch.toFixed(8) + ' BCH** more.' + neededLine + '\\n\\nType \\\`balance\\\` to re-check or try a different plan:' }, finish_reason: 'stop' }],
+                });
+                sseLine(res, {
+                  id: 'balance-err-done',
+                  object: 'chat.completion.chunk',
+                  choices: [{ index: 0, delta: {}, finish_reason: 'stop' }],
+                });
+                sseDone(res);
+                res.end();
+                return;
+              }
+            } else {
+              // LIFT path: fail fast if the wallet holds no LIFT tokens.
+              const liftBalanceUnits = await getLiftBalance();
+              if (liftBalanceUnits !== null && liftBalanceUnits <= 0) {
+                log('No LIFT tokens for wallet ' + walletHash?.substring(0, 16) + '...');
+                pendingPayments.delete(walletHash);
+                const addr = await getReceivingAddress();
+                const fundLine = addr ? '\\n\\n📥 **Add LIFT to your wallet:** \\\`' + addr + '\\\` (send LIFT tokens) or buy LIFT on the Cauldron DEX' : '';
+                sseLine(res, {
+                  id: 'lift-err',
+                  object: 'chat.completion.chunk',
+                  choices: [{ index: 0, delta: { content: PROXY_MARKER + '\\n\\n❌ **No LIFT tokens** — you need LIFT to pay with tokens. Add LIFT to your wallet, then type a plan number above or \\\`LIFT\\\` again.' + fundLine + '\\n\\nType \\\`balance\\\` to re-check:' }, finish_reason: 'stop' }],
+                });
+                sseLine(res, {
+                  id: 'lift-err-done',
+                  object: 'chat.completion.chunk',
+                  choices: [{ index: 0, delta: {}, finish_reason: 'stop' }],
+                });
+                sseDone(res);
+                res.end();
+                return;
+              }
             }
             
             // Keepalive during payment processing
@@ -1236,7 +1539,7 @@ const server = http.createServer(async (req, res) => {
               res.write(': keepalive\\n\\n');
             }, 2000);
 
-            runPaytacaPay(BACKEND_URL + '/v1', pendingPayload.body, walletHash, extraHeaders, async (err, responseJson) => {
+            runPaytacaPay(BACKEND_URL + '/v1', pendingPayload.body, walletHash, extraHeaders, pendingPayload.paymentMethod || 'bch', async (err, responseJson) => {
               pendingPayments.delete(walletHash);
               clearInterval(keepalive);
 
@@ -1299,7 +1602,18 @@ const server = http.createServer(async (req, res) => {
 
               if (wasStreaming) {
                 try {
-                  jsonToSse(res, chatCompletion, { prependContent: '\\n💳 Payment successful — generating your response...\\n\\n' });
+                  let prepend = '\\n💳 Payment successful — generating your response...\\n\\n';
+                  if (pendingPayload.paymentMethod === 'lift') {
+                    const liftPercent = await getLiftDiscountPercent();
+                    const selectedTier = (pendingPayload.tiers || []).find((t) => t.minutes === pendingPayload.durationMinutes);
+                    if (liftPercent > 0 && selectedTier && selectedTier.price_sats) {
+                      const savedBch = (selectedTier.price_sats * (liftPercent / 100) / 100000000).toFixed(8);
+                      prepend = '\\n💳 Payment successful — paid with LIFT (**' + liftPercent + '% off**, saved **' + savedBch + ' BCH**). Generating your response...\\n\\n';
+                    } else {
+                      prepend = '\\n💳 Payment successful — paid with LIFT tokens. Generating your response...\\n\\n';
+                    }
+                  }
+                  jsonToSse(res, chatCompletion, { prependContent: prepend });
                 } catch (e) { log('jsonToSse threw: ' + e.message); }
               } else {
                 try {
@@ -1345,7 +1659,7 @@ const server = http.createServer(async (req, res) => {
             res.write(': keepalive\\n\\n');
           }, 2000);
 
-          runPaytacaPay(BACKEND_URL + '/v1', pendingPayload.body, walletHash, extraHeaders, (err, responseJson) => {
+          runPaytacaPay(BACKEND_URL + '/v1', pendingPayload.body, walletHash, extraHeaders, 'bch', (err, responseJson) => {
             clearInterval(keepalive);
             if (err) {
               log('paytaca pay failed: ' + err.message);
@@ -1522,6 +1836,42 @@ const server = http.createServer(async (req, res) => {
           });
           
           if (tiers && tiers.length > 0) {
+            // AUTO-REFILL: when armed, buy the configured plan and retry the
+            // request without the interactive tier prompt. Falls through to the
+            // prompt when not armed, model mismatched, budget exhausted, plan
+            // no longer offered, or the wallet cannot fund the refill.
+            const refill = getAutoRefillState();
+            if (refill && autoRefillCanBuy(refill, modelId || requestModel)) {
+              const refillTier = (tiers || []).find((t) => Number(t.minutes) === Number(refill.minutes));
+              if (refillTier && refillTier.price_sats) {
+                if (refill.paymentMethod !== 'lift') {
+                  const currentBalanceSats = await getWalletBalance();
+                  if (currentBalanceSats === null || currentBalanceSats >= Number(refillTier.price_sats)) {
+                    const pp = pendingPayments.get(walletHash);
+                    await autoRefillAndRetry(res, walletHash, pp, refill);
+                    return;
+                  }
+                  log('AUTO-REFILL: insufficient balance (' + (currentBalanceSats === null ? 'n/a' : currentBalanceSats) + ' sats < ' + refillTier.price_sats + ') — disarming');
+                  refill.enabled = false;
+                  saveAutoRefillState(refill);
+                } else {
+                  const liftUnits = await getLiftBalance();
+                  if (liftUnits !== null && liftUnits > 0) {
+                    const pp = pendingPayments.get(walletHash);
+                    await autoRefillAndRetry(res, walletHash, pp, refill);
+                    return;
+                  }
+                  log('AUTO-REFILL: no LIFT tokens — disarming');
+                  refill.enabled = false;
+                  saveAutoRefillState(refill);
+                }
+              } else {
+                log('AUTO-REFILL: configured ' + refill.minutes + '-min plan not offered — disarming');
+                refill.enabled = false;
+                saveAutoRefillState(refill);
+              }
+            }
+
             // New flow: show tier selection prompt. Also tell the user about
             // other models that still have paid credits, so they can switch
             // instead of buying a plan for the currently selected model.
@@ -1615,9 +1965,9 @@ const server = http.createServer(async (req, res) => {
       };
 
       if (isStreaming) {
-        forwardStreaming(req, res, body, handleResponse);
+        await forwardStreaming(req, res, body, handleResponse);
       } else {
-        forwardToDjango(req, body, handleResponse);
+        await forwardToDjango(req, body, handleResponse);
       }
       
     } catch (err) {

package/dist/bundled/proxy.js.map

@@ -1 +1 @@
-{"version":3,"file":"proxy.js","sourceRoot":"","sources":["../../src/bundled/proxy.ts"],"names":[],"mappings":";AAAA,0DAA0D;AAC1D,6DAA6D;;;AAEhD,QAAA,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAonDnC,CAAC"}
+{"version":3,"file":"proxy.js","sourceRoot":"","sources":["../../src/bundled/proxy.ts"],"names":[],"mappings":";AAAA,0DAA0D;AAC1D,6DAA6D;;;AAEhD,QAAA,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAk9DnC,CAAC"}