@paytaca/opencode-plugin 0.1.6 → 0.1.8

package/dist/bundled/proxy.js

@@ -47,7 +47,7 @@ function log(message) {
 
 // Heartbeat monitoring - proxy exits if heartbeat is stale
 const HEARTBEAT_FILE = path.join(LOG_DIR, 'heartbeat');
-const HEARTBEAT_TIMEOUT = 15000; // 15 seconds
+const HEARTBEAT_TIMEOUT = 300000; // 5 minutes
 
 function checkHeartbeat() {
   try {
@@ -77,6 +77,8 @@ function checkHeartbeat() {
 let heartbeatChecker = null;
 
 // Store pending payment requests per wallet hash
+// Each entry: { body, modelId, displayName, durationMinutes, tiers[], step }
+// step: 'tier_select' (user must pick a tier) or 'approval' (yes/no)
 const pendingPayments = new Map();
 
 // Utility: run shell command and return output
@@ -149,6 +151,17 @@ async function checkWallet() {
   }
 }
 
+// Format seconds as MM:SS or HH:MM:SS
+function formatDuration(totalSeconds) {
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor((totalSeconds % 3600) / 60);
+  const secs = totalSeconds % 60;
+  if (hours > 0) {
+    return hours + ':' + String(minutes).padStart(2, '0') + ':' + String(secs).padStart(2, '0');
+  }
+  return minutes + ':' + String(secs).padStart(2, '0');
+}
+
 // SSE helper: write a data line
 function sseLine(res, data) {
   res.write('data: ' + JSON.stringify(data) + '\\n\\n');
@@ -159,8 +172,116 @@ function sseDone(res) {
   res.write('data: [DONE]\\n\\n');
 }
 
+// Build and stream SSE tier selection prompt
+async function streamTierSelectionPrompt(res, walletHash, modelName, tiers) {
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    'X-Payment-Required': 'true',
+    'Connection': 'keep-alive',
+  });
+
+  sseLine(res, {
+    id: 'tier-1',
+    object: 'chat.completion.chunk',
+    created: Math.floor(Date.now() / 1000),
+    model: modelName,
+    choices: [{ index: 0, delta: { role: 'assistant' }, finish_reason: null }],
+  });
+
+  // Loading sequence
+  sseLine(res, {
+    id: 'tier-2',
+    object: 'chat.completion.chunk',
+    choices: [{ index: 0, delta: { content: '⏳ Initializing Paytaca AI provider...\\n' }, finish_reason: null }],
+  });
+
+  const hasCli = await checkPaytacaCli();
+  sseLine(res, {
+    id: 'tier-3',
+    object: 'chat.completion.chunk',
+    choices: [{ index: 0, delta: { content: 'Checking Paytaca CLI... ' }, finish_reason: null }],
+  });
+  sseLine(res, {
+    id: 'tier-4',
+    object: 'chat.completion.chunk',
+    choices: [{ index: 0, delta: { content: hasCli ? '✅\\n' : '❌ Not found\\n' }, finish_reason: null }],
+  });
+
+  const hasWallet = hasCli ? await checkWallet() : false;
+  sseLine(res, {
+    id: 'tier-5',
+    object: 'chat.completion.chunk',
+    choices: [{ index: 0, delta: { content: 'Checking wallet... ' }, finish_reason: null }],
+  });
+  sseLine(res, {
+    id: 'tier-6',
+    object: 'chat.completion.chunk',
+    choices: [{ index: 0, delta: { content: hasWallet ? '✅\\n' : '❌ Not found\\n' }, finish_reason: null }],
+  });
+
+  const balanceSats = hasWallet ? await getWalletBalance() : null;
+  sseLine(res, {
+    id: 'tier-7',
+    object: 'chat.completion.chunk',
+    choices: [{ index: 0, delta: { content: 'Fetching balance... ' }, finish_reason: null }],
+  });
+
+  let balanceStr;
+  if (balanceSats !== null) {
+    const bch = (balanceSats / 100000000).toFixed(8);
+    balanceStr = bch + ' BCH';
+    sseLine(res, {
+      id: 'tier-8',
+      object: 'chat.completion.chunk',
+      choices: [{ index: 0, delta: { content: '✅ — ' + balanceStr + '\\n\\n' }, finish_reason: null }],
+    });
+  } else {
+    balanceStr = 'Unable to check';
+    sseLine(res, {
+      id: 'tier-8',
+      object: 'chat.completion.chunk',
+      choices: [{ index: 0, delta: { content: '\\n' + balanceStr + '\\n\\n' }, finish_reason: null }],
+    });
+  }
+
+  // Tier selection
+  sseLine(res, {
+    id: 'tier-9',
+    object: 'chat.completion.chunk',
+    choices: [{ index: 0, delta: { content: '💳 Select a plan for ' + (modelName || 'AI Model') + '\\n\\n' }, finish_reason: null }],
+  });
+
+  for (let i = 0; i < tiers.length; i++) {
+    const tier = tiers[i];
+    const bchAmount = (tier.price_sats / 100000000).toFixed(8);
+    const label = String(i + 1) + '️⃣   ';
+    sseLine(res, {
+      id: 'tier-10-' + i,
+      object: 'chat.completion.chunk',
+      choices: [{ index: 0, delta: { content: label + tier.minutes + ' minutes — ₱' + tier.price_php.toFixed(2) + ' (' + bchAmount + ' BCH)\\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 + ':' }, finish_reason: 'stop' }],
+  });
+
+  sseLine(res, {
+    id: 'tier-12',
+    object: 'chat.completion.chunk',
+    choices: [{ index: 0, delta: {}, finish_reason: 'stop' }],
+    usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+  });
+
+  sseDone(res);
+  res.end();
+}
+
 // Build and stream SSE loading sequence + payment prompt
-async function streamPaymentPrompt(res, walletHash, isRenewal = false, tokensUsed = 0, tokenLimit = 50000, carryoverDeadline = null) {
+async function streamPaymentPrompt(res, walletHash, isRenewal = false, tokensUsed = 0, tokenLimit = 50000, timeRemainingSeconds = 0) {
   res.writeHead(200, {
     'Content-Type': 'text/event-stream',
     'Cache-Control': 'no-cache',
@@ -193,7 +314,7 @@ async function streamPaymentPrompt(res, walletHash, isRenewal = false, tokensUse
     id: baseId + '-1',
     object: 'chat.completion.chunk',
     created: Math.floor(Date.now() / 1000),
-    model: 'deepseek-ai/DeepSeek-V4-Flash',
+    model: 'deepseek/deepseek-v4-flash',
     choices: [{ index: 0, delta: { role: 'assistant' }, finish_reason: null }],
   });
 
@@ -291,7 +412,8 @@ async function streamPaymentPrompt(res, walletHash, isRenewal = false, tokensUse
   }
   
   if (isRenewal) {
-    const unusedTokens = Math.max(0, tokenLimit - tokensUsed);
+    const usedMinutes = Math.round(timeRemainingSeconds / 60);
+    const remainingAttr = usedMinutes > 0 ? usedMinutes + ' min remaining' : 'depleted';
     sseLine(res, {
       id: baseId + '-11',
       object: 'chat.completion.chunk',
@@ -300,19 +422,8 @@ async function streamPaymentPrompt(res, walletHash, isRenewal = false, tokensUse
     sseLine(res, {
       id: baseId + '-12',
       object: 'chat.completion.chunk',
-      choices: [{ index: 0, delta: { content: 'Unused Tokens Carried Over: +' + unusedTokens.toLocaleString() + '\\n' }, finish_reason: null }],
+      choices: [{ index: 0, delta: { content: '⏱ Time Credits: ' + remainingAttr + '\\n' }, finish_reason: null }],
     });
-    if (carryoverDeadline) {
-      const minutesLeft = Math.max(0, Math.floor((new Date(carryoverDeadline) - Date.now()) / 60000));
-      const timeStr = minutesLeft > 0
-        ? minutesLeft + ' min' + (minutesLeft !== 1 ? 's' : '') + ' remaining'
-        : 'expired — renew now to keep them';
-      sseLine(res, {
-        id: baseId + '-12b',
-        object: 'chat.completion.chunk',
-        choices: [{ index: 0, delta: { content: '⏰ Carryover expires in ' + timeStr + '\\n' }, finish_reason: null }],
-      });
-    }
   }
   
   sseLine(res, {
@@ -476,7 +587,7 @@ function forceNonStreaming(body) {
 // Convert a chat.completion JSON object to SSE format
 function jsonToSse(res, chatCompletion) {
   const content = chatCompletion.choices?.[0]?.message?.content || '';
-  const model = chatCompletion.model || 'deepseek-ai/DeepSeek-V4-Flash';
+  const model = chatCompletion.model || chatCompletion.model_id || 'deepseek/deepseek-v4-flash';
   const created = chatCompletion.created || Math.floor(Date.now() / 1000);
 
 
@@ -542,7 +653,7 @@ function jsonToSse(res, chatCompletion) {
 }
 
 // Run paytaca pay internally and return the response
-function runPaytacaPay(djangoUrl, body, walletHash, callback) {
+function runPaytacaPay(djangoUrl, body, walletHash, extraHeaders, callback) {
   const url = djangoUrl + '/chat/completions?wallet_hash=' + encodeURIComponent(walletHash || '');
   const payBody = forceNonStreaming(body);
 
@@ -560,7 +671,7 @@ function runPaytacaPay(djangoUrl, body, walletHash, callback) {
   const config = {
     url,
     method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
+    headers: Object.assign({ 'Content-Type': 'application/json' }, extraHeaders || {}),
     bodyFile,
     confirmed: true,
   };
@@ -652,7 +763,7 @@ const server = http.createServer(async (req, res) => {
   // Enable CORS
   res.setHeader('Access-Control-Allow-Origin', '*');
   res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, X-Wallet-Hash, Authorization');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, X-Wallet-Hash, X-Model-Id, X-Duration-Minutes, Payment-Signature, Authorization');
   
   if (req.method === 'OPTIONS') {
     res.writeHead(200);
@@ -681,11 +792,22 @@ const server = http.createServer(async (req, res) => {
     res.end(JSON.stringify({
       proxy_url: 'http://localhost:' + PROXY_PORT + '/v1',
       django_url: BACKEND_URL + '/v1',
-      cost_sats: 6000,
-      cost_bch: '0.00006',
       payment_address: '',
-      session_duration_minutes: 5,
-      token_limit: 50000,
+      default_model: 'deepseek/deepseek-v4-flash',
+      default_duration_minutes: 30,
+      models: [
+        {
+          id: 'deepseek/deepseek-v4-flash',
+          object: 'model',
+          display_name: 'DeepSeek V4 Flash',
+          provider: 'openrouter',
+          price_tiers: [
+            { minutes: 10, price_php: 5.0, price_sats: 45000 },
+            { minutes: 30, price_php: 12.0, price_sats: 108000 },
+            { minutes: 60, price_php: 20.0, price_sats: 180000 },
+          ],
+        },
+      ],
       context_retention_hours: 2,
     }));
     return;
@@ -715,13 +837,131 @@ const server = http.createServer(async (req, res) => {
       
       
       if (pendingPayload) {
-        // User responded to a payment prompt
+        // Check for tier selection first
+        if (pendingPayload.step === 'tier_select' && pendingPayload.tiers && pendingPayload.tiers.length > 0) {
+          const userInput = lastContent.trim();
+          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;
+          } 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;
+              }
+            }
+          }
+          
+          if (selectedIndex >= 0) {
+            const selectedTier = pendingPayload.tiers[selectedIndex];
+            pendingPayload.durationMinutes = selectedTier.minutes;
+            pendingPayload.step = 'processing';
+            
+            log('Tier selected: ' + selectedTier.minutes + ' min for wallet ' + walletHash?.substring(0, 16) + '...');
+            
+            // Build extra headers for payment wrapper
+            const extraHeaders = {};
+            if (pendingPayload.modelId) {
+              extraHeaders['X-Model-Id'] = pendingPayload.modelId;
+            }
+            extraHeaders['X-Duration-Minutes'] = String(selectedTier.minutes);
+            
+            // 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: '\\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;
+            }
+            
+            runPaytacaPay(BACKEND_URL + '/v1', pendingPayload.body, walletHash, extraHeaders, (err, responseJson) => {
+              pendingPayments.delete(walletHash);
+              
+              if (err) {
+                log('paytaca pay failed: ' + err.message);
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ 
+                  error: 'Payment failed', 
+                  message: err.message,
+                  details: 'Please check your wallet balance and try again.'
+                }));
+                return;
+              }
+              
+              if (!responseJson.success) {
+                res.writeHead(responseJson.status || 500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ 
+                  error: 'Payment failed', 
+                  message: responseJson.error,
+                  details: 'Payment was not successful. Please check your balance and try again.'
+                }));
+                return;
+              }
+              
+              const chatCompletion = responseJson?.data || responseJson;
+              
+              let wasStreaming = false;
+              try {
+                wasStreaming = JSON.parse(pendingPayload.body).stream === true;
+              } catch {}
+              
+              log('paytaca pay succeeded. Returning chat response.');
+              
+              if (wasStreaming) {
+                try {
+                  jsonToSse(res, chatCompletion);
+                } catch (e) {}
+              } else {
+                try {
+                  res.writeHead(200, { 'Content-Type': 'application/json' });
+                  res.end(JSON.stringify(chatCompletion));
+                } catch (e) {}
+              }
+            });
+            return;
+          } else {
+            // Invalid selection — reshow the prompt
+            log('Invalid tier selection for wallet ' + walletHash?.substring(0, 16) + '...');
+            await streamTierSelectionPrompt(res, walletHash, pendingPayload.displayName || pendingPayload.modelId || 'AI Model', pendingPayload.tiers);
+            return;
+          }
+        }
+        
+        // Old flow: user responded to a yes/no payment prompt
         if (lastContent === 'yes') {
-          // User approved — run paytaca pay with the stored original payload
           log('Payment approved by wallet ' + walletHash?.substring(0, 16) + '...');
           pendingPayments.delete(walletHash);
           
-          runPaytacaPay(BACKEND_URL + '/v1', pendingPayload, walletHash, (err, responseJson) => {
+          const extraHeaders = {};
+          if (pendingPayload.modelId) {
+            extraHeaders['X-Model-Id'] = pendingPayload.modelId;
+          }
+          if (pendingPayload.durationMinutes) {
+            extraHeaders['X-Duration-Minutes'] = String(pendingPayload.durationMinutes);
+          }
+          
+          runPaytacaPay(BACKEND_URL + '/v1', pendingPayload.body, walletHash, extraHeaders, (err, responseJson) => {
             if (err) {
               log('paytaca pay failed: ' + err.message);
               res.writeHead(500, { 'Content-Type': 'application/json' });
@@ -733,8 +973,6 @@ const server = http.createServer(async (req, res) => {
               return;
             }
             
-            
-            // Check if the response indicates success
             if (!responseJson.success) {
               res.writeHead(responseJson.status || 500, { 'Content-Type': 'application/json' });
               res.end(JSON.stringify({ 
@@ -746,12 +984,10 @@ const server = http.createServer(async (req, res) => {
             }
             
             const chatCompletion = responseJson?.data || responseJson;
-            if (chatCompletion.choices) {
-            }
             
             let wasStreaming = false;
             try {
-              wasStreaming = JSON.parse(pendingPayload).stream === true;
+              wasStreaming = JSON.parse(pendingPayload.body).stream === true;
             } catch {}
             
             log('paytaca pay succeeded. Returning chat response.');
@@ -759,20 +995,17 @@ const server = http.createServer(async (req, res) => {
             if (wasStreaming) {
               try {
                 jsonToSse(res, chatCompletion);
-              } catch (e) {
-              }
+              } catch (e) {}
             } else {
               try {
                 res.writeHead(200, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify(chatCompletion));
-              } catch (e) {
-              }
+              } catch (e) {}
             }
           });
           return;
           
         } else if (lastContent === 'no') {
-          // User declined
           log('Payment declined by wallet ' + walletHash?.substring(0, 16) + '...');
           pendingPayments.delete(walletHash);
 
@@ -785,7 +1018,7 @@ const server = http.createServer(async (req, res) => {
             id: 'payment-declined',
             object: 'chat.completion',
             created: Math.floor(Date.now() / 1000),
-            model: 'deepseek-ai/DeepSeek-V4-Flash',
+            model: pendingPayload.modelId || 'deepseek/deepseek-v4-flash',
             choices: [{
               index: 0,
               message: {
@@ -804,6 +1037,65 @@ const server = http.createServer(async (req, res) => {
         }
       }
       
+      // Handle time/credits command — show remaining time credits
+      const cmd = lastContent?.trim().toLowerCase();
+      if (cmd === 'time' || cmd === 'credit' || cmd === 'credits') {
+        log('Time command for wallet ' + walletHash?.substring(0, 16) + '...');
+        const statusUrl = BACKEND_URL + '/v1/wallet/status';
+        const statusRes = await fetch(statusUrl, {
+          headers: { 'X-Wallet-Hash': walletHash }
+        });
+        let content;
+        if (statusRes.ok) {
+          const statusData = await statusRes.json();
+          const sessions = statusData.sessions || [];
+          const activeSessions = sessions.filter(s => s.time_remaining_seconds > 0 && s.model_active);
+          const inactiveSessions = sessions.filter(s => s.time_remaining_seconds > 0 && !s.model_active);
+          const parts = [];
+          if (activeSessions.length > 0) {
+            parts.push('**⏱️  Active Time Credits:**');
+            activeSessions.forEach(s => {
+              const total = formatDuration(s.time_credits_seconds);
+              const remaining = formatDuration(s.time_remaining_seconds);
+              const used = formatDuration(s.time_used_seconds);
+              parts.push('  - **' + (s.display_name || s.ai_model) + '** — ' + remaining + ' remaining of ' + total + ' (' + used + ' used)');
+            });
+          }
+          if (inactiveSessions.length > 0) {
+            parts.push('\\n**⚠️  Inactive Model:**');
+            inactiveSessions.forEach(s => {
+              const remaining = formatDuration(s.time_remaining_seconds);
+              parts.push('  - **' + (s.display_name || s.ai_model) + ' (Inactive)** — ' + remaining + ' remaining');
+            });
+          }
+          content = parts.length > 0 ? parts.join('\\n') : '⏱️  No active time credits.';
+        } else {
+          content = '⏱️  Unable to check time credits.';
+        }
+        
+        sseLine(res, {
+          id: 'time-1',
+          object: 'chat.completion.chunk',
+          created: Math.floor(Date.now() / 1000),
+          model: 'deepseek/deepseek-v4-flash',
+          choices: [{ index: 0, delta: { role: 'assistant' }, finish_reason: null }],
+        });
+        sseLine(res, {
+          id: 'time-2',
+          object: 'chat.completion.chunk',
+          choices: [{ index: 0, delta: { content: content + '\\n' }, finish_reason: 'stop' }],
+        });
+        sseLine(res, {
+          id: 'time-3',
+          object: 'chat.completion.chunk',
+          choices: [{ index: 0, delta: {}, finish_reason: 'stop' }],
+          usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+        });
+        sseDone(res);
+        res.end();
+        return;
+      }
+      
       let isStreaming = true;
       try { isStreaming = JSON.parse(body).stream !== false; } catch {}
 
@@ -819,20 +1111,56 @@ const server = http.createServer(async (req, res) => {
 
         if (statusCode === 402) {
           log('402 intercepted for wallet ' + walletHash?.substring(0, 16) + '...');
-          pendingPayments.set(walletHash, body);
+          
+          // Parse 402 response for model_id and price_tiers
+          let modelId = null;
+          let displayName = null;
+          let tiers = null;
+          try {
+            const parsed = JSON.parse(responseBody);
+            modelId = parsed.model_id || null;
+            displayName = parsed.display_name || null;
+            tiers = parsed.price_tiers || null;
+          } catch (e) {
+            log('Could not parse 402 body: ' + e.message);
+          }
+          
+          pendingPayments.set(walletHash, {
+            body: body,
+            modelId: modelId,
+            durationMinutes: null,
+            tiers: tiers,
+            step: tiers ? 'tier_select' : 'approval'
+          });
+          
+          if (tiers && tiers.length > 0) {
+            // New flow: show tier selection prompt
+            await streamTierSelectionPrompt(res, walletHash, displayName || modelId || 'AI Model', tiers);
+            return;
+          }
           
           // Check session status to determine if this is a renewal
           let isRenewal = false;
           let tokensUsed = 0;
           let tokenLimit = 50000;
-          let carryoverDeadline = null;
+          let timeRemainingSeconds = 0;
           
+          let statusModelId = modelId;
           try {
+            // Extract model from the original request body if not in 402
+            if (!statusModelId) {
+              try {
+                const bodyParsed = JSON.parse(body);
+                statusModelId = bodyParsed.model || null;
+              } catch (e) {}
+            }
+            
+            const statusPath = '/v1/wallet/status' + (statusModelId ? '?model_id=' + encodeURIComponent(statusModelId) : '');
             const statusResponse = await new Promise((resolve, reject) => {
               const statusReq = REQUester.get({
                 hostname: DJANGO_HOST,
                 port: DJANGO_PORT,
-                path: '/v1/wallet/status',
+                path: statusPath,
                 headers: { 'X-Wallet-Hash': walletHash }
               }, (res) => {
                 let data = '';
@@ -852,20 +1180,17 @@ const server = http.createServer(async (req, res) => {
             if (statusResponse) {
               tokensUsed = statusResponse.tokens_used || 0;
               tokenLimit = statusResponse.token_limit || 50000;
-              carryoverDeadline = statusResponse.carryover_deadline || null;
-              
-              const hasExpiredSession = !statusResponse.session_active && tokensUsed > 0;
-              const carryoverStillValid = (statusResponse.carryover_remaining_minutes || 0) > 0;
+              timeRemainingSeconds = statusResponse.time_remaining_seconds || 0;
               
-              // Renewal if: (1) session active but tokens exhausted, OR (2) session expired with valid carryover
-              isRenewal = (statusResponse.session_active && tokensUsed >= tokenLimit) ||
-                         (hasExpiredSession && carryoverStillValid);
+              // Renewal if session has been used (tokens > 0 or time > 0) but is now exhausted
+              isRenewal = (tokensUsed > 0 || statusResponse.time_used_seconds > 0) &&
+                          (!statusResponse.session_active || timeRemainingSeconds <= 0);
             }
           } catch (err) {
             log('Failed to check session status: ' + err.message);
           }
           
-          await streamPaymentPrompt(res, walletHash, isRenewal, tokensUsed, tokenLimit, carryoverDeadline);
+          await streamPaymentPrompt(res, walletHash, isRenewal, tokensUsed, tokenLimit, timeRemainingSeconds);
         } else {
           if (res.headersSent) {
             log('Streaming response completed and already sent');

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAq6BnC,CAAC"}
+{"version":3,"file":"proxy.js","sourceRoot":"","sources":["../../src/bundled/proxy.ts"],"names":[],"mappings":";AAAA,0DAA0D;AAC1D,6DAA6D;;;AAEhD,QAAA,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0uCnC,CAAC"}

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAGjC,eAAO,MAAM,mBAAmB,2BAA2B,CAAC;AAC5D,eAAO,MAAM,kBAAkB,OAAO,CAAC;AAGvC,wBAAgB,YAAY,IAAI,MAAM,CAGrC;AAED,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAIvD;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAiCpD;AAED,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAIlE;AAED,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE1D;AAGD,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAQvD;AAGD,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC,OAAO,CAOhE"}

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAOA,iBAAe,cAAc,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,QAAQ,CAAC,EAAE,GAAG;;;;kBA6FlC,GAAG;6BA8CQ,GAAG,UAAU,GAAG;GAMlD;;;;;AAED,kBAAoE"}