@token2chat/t2c 0.2.0-beta.1 → 0.2.1

package/dist/proxy.js

@@ -3,62 +3,13 @@
  * into ecash-paid requests to the token2chat Gate.
  */
 import { createServer } from "node:http";
-import crypto from "node:crypto";
 import { CashuStore } from "./cashu-store.js";
-import { resolveHome, FAILED_TOKENS_PATH, appendFailedToken, appendTransaction, loadOrCreateProxySecret } from "./config.js";
+import { resolveHome, appendFailedToken, appendTransaction, loadOrCreateProxySecret } from "./config.js";
 import { GateRegistry } from "./gate-discovery.js";
-const defaultLogger = {
-    info: (...args) => console.log("[t2c]", ...args),
-    warn: (...args) => console.warn("[t2c]", ...args),
-    error: (...args) => console.error("[t2c]", ...args),
-};
-/**
- * Known provider prefixes for model ID transformation.
- * We use `-` as separator in OpenClaw to avoid double-slash issue,
- * but Gate/OpenRouter expects `/` as separator.
- */
-const MODEL_PROVIDER_PREFIXES = [
-    "openai",
-    "anthropic",
-    "google",
-    "deepseek",
-    "qwen",
-    "moonshotai",
-    "mistralai",
-    "meta-llama",
-    "nvidia",
-    "cohere",
-    "perplexity",
-];
-/**
- * Transform model ID from dash format to slash format.
- * e.g., "anthropic-claude-sonnet-4.5" → "anthropic/claude-sonnet-4.5"
- */
-function transformModelId(model) {
-    for (const prefix of MODEL_PROVIDER_PREFIXES) {
-        if (model.startsWith(`${prefix}-`)) {
-            return `${prefix}/${model.slice(prefix.length + 1)}`;
-        }
-    }
-    return model;
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-const MAX_RETRY_DELAY_MS = 30_000;
-function parseRetryAfter(value) {
-    if (!value)
-        return null;
-    const seconds = parseFloat(value);
-    if (!isNaN(seconds) && isFinite(seconds)) {
-        return Math.max(0, Math.ceil(seconds * 1000));
-    }
-    const date = new Date(value);
-    if (!isNaN(date.getTime())) {
-        return Math.max(0, date.getTime() - Date.now());
-    }
-    return null;
-}
+import { defaultLogger, transformModelId, parseRetryAfter, MAX_BODY_SIZE, MAX_RETRY_DELAY_MS, DEFAULT_RETRY_CONFIG, PricingCache, GateClient, PaymentService, createAuthChecker, handleError, sendJsonResponse, } from "./proxy/index.js";
+import { extractCashuChangeFromSSE } from "./proxy/sse-parser.js";
+// Re-export for backwards compatibility
+export { transformModelId, parseRetryAfter };
 export async function startProxy(config, logger = defaultLogger) {
     const { gateUrl, mintUrl, proxyPort: port, lowBalanceThreshold } = config;
     const walletPath = resolveHome(config.walletPath);
@@ -71,56 +22,28 @@ export async function startProxy(config, logger = defaultLogger) {
     }
     // Load proxy authentication secret
     const proxySecret = await loadOrCreateProxySecret();
-    function checkAuth(req) {
-        const auth = req.headers.authorization;
-        if (!auth)
-            return false;
-        const parts = auth.split(" ");
-        if (parts.length !== 2 || parts[0] !== "Bearer")
-            return false;
-        const provided = Buffer.from(parts[1]);
-        const expected = Buffer.from(proxySecret);
-        if (provided.length !== expected.length)
-            return false;
-        return crypto.timingSafeEqual(provided, expected);
-    }
+    const checkAuth = createAuthChecker(proxySecret);
     // Load wallet synchronously before starting server (fixes race condition)
     let wallet;
     try {
         wallet = await CashuStore.load(walletPath, mintUrl);
-        logger.info(`Wallet loaded: ${wallet.balance} sat (${wallet.proofCount} proofs)`);
+        logger.info(`Wallet loaded: balance=${wallet.balance} (${wallet.proofCount} proofs)`);
     }
     catch (e) {
         logger.error("Failed to load wallet:", e);
         throw new Error(`Cannot start proxy: wallet load failed - ${e instanceof Error ? e.message : e}`);
     }
-    // Cache pricing info
-    let pricingCache = null;
-    let pricingFetchedAt = 0;
-    async function fetchPricing() {
-        const now = Date.now();
-        if (pricingCache && now - pricingFetchedAt < 5 * 60_000)
-            return pricingCache;
-        try {
-            const res = await fetch(`${gateUrl}/v1/pricing`);
-            if (res.ok) {
-                const data = (await res.json());
-                pricingCache = {};
-                for (const [model, rule] of Object.entries(data.models)) {
-                    pricingCache[model] = rule.per_request;
-                }
-                pricingFetchedAt = now;
-            }
-        }
-        catch (e) {
-            logger.warn("Failed to fetch pricing:", e);
-        }
-        return pricingCache ?? {};
-    }
-    function getPrice(pricing, model) {
-        return pricing[model] ?? pricing["*"] ?? 500;
-    }
-    const MAX_BODY_SIZE = 10 * 1024 * 1024; // 10 MB
+    // Pricing cache
+    const pricingCache = new PricingCache(gateUrl);
+    // Gate client
+    const gateClient = new GateClient(gateUrl, { logger });
+    // Payment service
+    const paymentService = new PaymentService({
+        wallet,
+        logger,
+        appendFailedToken,
+        lowBalanceThreshold,
+    });
     async function readBody(req) {
         const chunks = [];
         let size = 0;
@@ -137,14 +60,12 @@ export async function startProxy(config, logger = defaultLogger) {
     const server = createServer(async (req, res) => {
         // Health check (unauthenticated — no sensitive data)
         if (req.method === "GET" && req.url === "/health") {
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ ok: true }));
+            sendJsonResponse(res, 200, { ok: true });
             return;
         }
         // All endpoints below require authentication
         if (!checkAuth(req)) {
-            res.writeHead(401, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: { message: "Unauthorized. Provide a valid Bearer token." } }));
+            sendJsonResponse(res, 401, { error: { message: "Unauthorized. Provide a valid Bearer token." } });
             return;
         }
         // Pricing passthrough
@@ -155,28 +76,25 @@ export async function startProxy(config, logger = defaultLogger) {
                 res.end(await upstream.text());
             }
             catch {
-                res.writeHead(502, { "Content-Type": "application/json" });
-                res.end(JSON.stringify({ error: "Gate unreachable" }));
+                sendJsonResponse(res, 502, { error: "Gate unreachable" });
             }
             return;
         }
         // Models endpoint
         if (req.method === "GET" && req.url === "/v1/models") {
-            const pricing = await fetchPricing();
-            const models = Object.keys(pricing).map((id) => ({
+            await pricingCache.get(); // Ensure cache is populated
+            const models = pricingCache.getModels().map((id) => ({
                 id,
                 object: "model",
                 created: Date.now(),
                 owned_by: "token2chat",
             }));
-            res.writeHead(200, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ object: "list", data: models }));
+            sendJsonResponse(res, 200, { object: "list", data: models });
             return;
         }
         // Only proxy POST /v1/chat/completions
         if (req.method !== "POST" || !req.url?.startsWith("/v1/chat/completions")) {
-            res.writeHead(404, { "Content-Type": "application/json" });
-            res.end(JSON.stringify({ error: { message: "Not found" } }));
+            sendJsonResponse(res, 404, { error: { message: "Not found" } });
             return;
         }
         try {
@@ -189,20 +107,15 @@ export async function startProxy(config, logger = defaultLogger) {
             const txId = `tx-${txStart}-${Math.random().toString(36).slice(2, 8)}`;
             let txChangeSat = 0;
             let txRefundSat = 0;
-            const balanceBefore = wallet.balance;
-            const pricing = await fetchPricing();
-            const price = getPrice(pricing, requestedModel);
-            const balance = wallet.balance;
-            if (balance < price) {
-                logger.warn(`Insufficient balance: ${balance} sat < ${price} sat for ${requestedModel}`);
-                res.writeHead(402, { "Content-Type": "application/json" });
-                res.end(JSON.stringify({
-                    error: {
-                        code: "insufficient_balance",
-                        message: `Wallet balance ${balance} sat < ${price} sat required. Run 't2c mint' to add funds.`,
-                        type: "insufficient_funds",
-                    },
-                }));
+            const balanceBefore = paymentService.getBalance();
+            await pricingCache.get(); // Ensure cache is populated
+            const price = pricingCache.getPrice(requestedModel);
+            // Check balance using PaymentService (throws InsufficientBalanceError)
+            try {
+                paymentService.checkBalance(price, requestedModel);
+            }
+            catch (e) {
+                handleError(res, e, logger);
                 return;
             }
             // Prepare modified body once (model transform doesn't change between retries)
@@ -212,51 +125,33 @@ export async function startProxy(config, logger = defaultLogger) {
             const gateUrls = gateRegistry
                 ? await gateRegistry.selectGate(requestedModel)
                 : [gateUrl];
-            // Make request with retry logic
-            const maxRetries = 2;
-            const retryBaseDelayMs = 2000;
-            let lastResponse = null;
-            let lastResponseBody;
+            // Make request with retry logic (new token per attempt for ecash)
+            const { maxRetries, baseDelayMs } = DEFAULT_RETRY_CONFIG;
+            let lastGateResponse = null;
             for (let attempt = 0; attempt <= maxRetries; attempt++) {
                 // Pick gate for this attempt (rotate through available gates)
                 const currentGateUrl = gateUrls[attempt % gateUrls.length];
-                const currentPrice = getPrice(pricing, requestedModel);
-                const token = await wallet.selectAndEncode(currentPrice);
-                const currentBalance = wallet.balance;
+                const currentPrice = pricingCache.getPrice(requestedModel);
+                // Select token using PaymentService
+                const { token, balanceAfter } = await paymentService.selectToken(currentPrice);
                 if (attempt === 0) {
-                    logger.info(`Paying ${currentPrice} sat for ${requestedModel} → ${currentGateUrl} (balance: ${currentBalance + currentPrice} → ~${currentBalance})`);
+                    logger.info(`Paying ${currentPrice} for ${requestedModel} → ${currentGateUrl} (balance: ${balanceAfter + currentPrice} → ~${balanceAfter})`);
                 }
                 else {
                     logger.info(`Retry ${attempt}/${maxRetries} for ${requestedModel} → ${currentGateUrl}`);
                 }
-                const gateRes = await fetch(`${currentGateUrl}/v1/chat/completions`, {
-                    method: "POST",
-                    headers: {
-                        "Content-Type": "application/json",
-                        "X-Cashu": token,
-                    },
+                // Use GateClient for the actual request
+                const gateRes = await gateClient.request({
+                    path: "/v1/chat/completions",
                     body: modifiedBody,
+                    token,
+                    gateUrl: currentGateUrl,
+                    stream: isStream,
                 });
-                // Handle change/refund tokens from Gate
-                for (const [header, type] of [["X-Cashu-Change", "change"], ["X-Cashu-Refund", "refund"]]) {
-                    const tokenStr = gateRes.headers.get(header);
-                    if (!tokenStr)
-                        continue;
-                    try {
-                        const amt = await wallet.receiveToken(tokenStr);
-                        if (type === "change")
-                            txChangeSat += amt;
-                        else
-                            txRefundSat += amt;
-                        logger.info(`Received ${amt} sat ${type}`);
-                    }
-                    catch (e) {
-                        const errMsg = e instanceof Error ? e.message : String(e);
-                        logger.warn(`Failed to store ${type}: ${errMsg}`);
-                        logger.warn(`Token saved to ${FAILED_TOKENS_PATH} - run 't2c recover' to retry`);
-                        await appendFailedToken(tokenStr, type, errMsg);
-                    }
-                }
+                // Handle change/refund tokens using PaymentService
+                const tokens = await paymentService.processGateTokens(gateRes.changeToken, gateRes.refundToken);
+                txChangeSat += tokens.changeSat;
+                txRefundSat += tokens.refundSat;
                 // If not 429, we're done (and mark gate healthy for failover)
                 if (gateRes.status !== 429) {
                     if (gateRegistry) {
@@ -266,12 +161,13 @@ export async function startProxy(config, logger = defaultLogger) {
                             gateRegistry.markSuccess(currentGateUrl);
                     }
                     const resHeaders = {};
-                    const ct = gateRes.headers.get("content-type");
-                    if (ct)
-                        resHeaders["Content-Type"] = ct;
+                    if (gateRes.contentType)
+                        resHeaders["Content-Type"] = gateRes.contentType;
                     res.writeHead(gateRes.status, resHeaders);
-                    if (isStream && gateRes.body) {
-                        const reader = gateRes.body.getReader();
+                    if (isStream && gateRes.stream) {
+                        // Filter out cashu-change SSE events from stream
+                        const { filtered, changeToken: sseChangeToken } = extractCashuChangeFromSSE(gateRes.stream);
+                        const reader = filtered.getReader();
                         try {
                             while (true) {
                                 const { done, value } = await reader.read();
@@ -284,20 +180,23 @@ export async function startProxy(config, logger = defaultLogger) {
                             reader.releaseLock();
                         }
                         res.end();
+                        // Process SSE change token (if any)
+                        const sseChange = sseChangeToken();
+                        if (sseChange) {
+                            const sseChangeResult = await paymentService.receiveChange(sseChange);
+                            txChangeSat += sseChangeResult;
+                        }
                     }
                     else {
-                        res.end(await gateRes.text());
+                        res.end(gateRes.body ?? "");
                     }
                     // Log balance warning
-                    const newBalance = wallet.balance;
-                    if (newBalance < lowBalanceThreshold) {
-                        logger.warn(`⚠️ Low ecash balance: ${newBalance} sat (threshold: ${lowBalanceThreshold})`);
-                    }
+                    paymentService.checkLowBalance();
                     // Record transaction
                     appendTransaction({
                         id: txId, timestamp: txStart, model: requestedModel,
                         priceSat: currentPrice, changeSat: txChangeSat, refundSat: txRefundSat,
-                        gateStatus: gateRes.status, balanceBefore, balanceAfter: wallet.balance,
+                        gateStatus: gateRes.status, balanceBefore, balanceAfter: paymentService.getBalance(),
                         durationMs: Date.now() - txStart,
                     }).catch(() => { });
                     return;
@@ -305,37 +204,26 @@ export async function startProxy(config, logger = defaultLogger) {
                 // Store last 429 response — mark gate for failover
                 if (gateRegistry)
                     gateRegistry.markFailed(currentGateUrl);
-                lastResponse = gateRes;
-                lastResponseBody = await gateRes.text();
-                // On 429, calculate backoff delay
+                lastGateResponse = { status: gateRes.status, body: gateRes.body };
+                // On 429, calculate backoff delay (GateClient doesn't retry, we do it here for new tokens)
                 if (attempt < maxRetries) {
-                    const retryAfterMs = parseRetryAfter(gateRes.headers.get("Retry-After"));
-                    const backoffMs = Math.min(retryAfterMs ?? retryBaseDelayMs * Math.pow(2, attempt), MAX_RETRY_DELAY_MS);
+                    const backoffMs = Math.min(baseDelayMs * Math.pow(2, attempt), MAX_RETRY_DELAY_MS);
                     logger.warn(`Rate limited (429), retrying in ${backoffMs}ms...`);
-                    await sleep(backoffMs);
+                    await new Promise((r) => setTimeout(r, backoffMs));
                 }
             }
             // All retries exhausted — record failed transaction
             appendTransaction({
                 id: txId, timestamp: txStart, model: requestedModel,
                 priceSat: price, changeSat: txChangeSat, refundSat: txRefundSat,
-                gateStatus: lastResponse.status, balanceBefore, balanceAfter: wallet.balance,
+                gateStatus: lastGateResponse.status, balanceBefore, balanceAfter: paymentService.getBalance(),
                 durationMs: Date.now() - txStart, error: "Rate limited after retries",
             }).catch(() => { });
-            res.writeHead(lastResponse.status, { "Content-Type": "application/json" });
-            res.end(lastResponseBody);
+            res.writeHead(lastGateResponse.status, { "Content-Type": "application/json" });
+            res.end(lastGateResponse.body ?? "");
         }
         catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
-            logger.error("Proxy error:", e);
-            if (msg === "Request body too large") {
-                res.writeHead(413, { "Content-Type": "application/json" });
-                res.end(JSON.stringify({ error: { code: "payload_too_large", message: "Request body too large" } }));
-            }
-            else {
-                res.writeHead(500, { "Content-Type": "application/json" });
-                res.end(JSON.stringify({ error: { code: "proxy_error", message: "Internal proxy error" } }));
-            }
+            handleError(res, e, logger);
         }
     });
     server.listen(port, "127.0.0.1", () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@token2chat/t2c",
-  "version": "0.2.0-beta.1",
+  "version": "0.2.1",
   "type": "module",
   "license": "MIT",
   "description": "t2c - Pay-per-request LLM access via Cashu ecash",
@@ -27,7 +27,7 @@
     "cli"
   ],
   "bin": {
-    "t2c": "./dist/index.js"
+    "t2c": "dist/index.js"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -67,9 +67,12 @@
   "dependencies": {
     "@cashu/cashu-ts": "^2.5.0",
     "@cashu/crypto": "^0.3.4",
+    "blessed": "^0.1.81",
+    "blessed-contrib": "^4.11.0",
     "commander": "^14.0.0"
   },
   "devDependencies": {
+    "@types/blessed": "^0.1.27",
     "@types/node": "^25.1.0",
     "@vitest/coverage-v8": "^3.2.4",
     "typescript": "^5.9.3",