@token2chat/t2c 0.2.0-beta.1 → 0.2.0

package/dist/proxy/sse-parser.js

@@ -0,0 +1,80 @@
+/**
+ * SSE stream parser that extracts cashu-change events.
+ *
+ * The Gate emits change tokens via `event: cashu-change` SSE events
+ * during streaming responses. This parser intercepts those events,
+ * extracts the token, and filters them out so they are not forwarded
+ * to the AI tool.
+ */
+/**
+ * Create a TransformStream that filters out `event: cashu-change` SSE events
+ * and captures the token data.
+ */
+export function extractCashuChangeFromSSE(input) {
+    let token;
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const filtered = new ReadableStream({
+        async start() { },
+        async pull(controller) {
+            // This is handled via piping below
+        },
+        cancel() { },
+    });
+    // Use a TransformStream approach
+    const encoder = new TextEncoder();
+    let resolveReady = null;
+    const transform = new TransformStream({
+        transform(chunk, controller) {
+            buffer += decoder.decode(chunk, { stream: true });
+            // Process complete SSE blocks (separated by \n\n)
+            while (true) {
+                const blockEnd = buffer.indexOf("\n\n");
+                if (blockEnd === -1)
+                    break;
+                const block = buffer.slice(0, blockEnd + 2);
+                buffer = buffer.slice(blockEnd + 2);
+                // Check if this block is a cashu-change event
+                if (isCashuChangeBlock(block)) {
+                    // Extract the token from "data: <token>\n"
+                    const dataMatch = block.match(/^data:\s*(.+)$/m);
+                    if (dataMatch && !token) {
+                        token = dataMatch[1].trim();
+                    }
+                    // Don't forward this block
+                    continue;
+                }
+                // Forward non-cashu-change blocks
+                controller.enqueue(encoder.encode(block));
+            }
+        },
+        flush(controller) {
+            // Flush any remaining buffer
+            if (buffer.length > 0) {
+                // Check if remaining buffer is a cashu-change event
+                if (isCashuChangeBlock(buffer)) {
+                    const dataMatch = buffer.match(/^data:\s*(.+)$/m);
+                    if (dataMatch && !token) {
+                        token = dataMatch[1].trim();
+                    }
+                }
+                else {
+                    controller.enqueue(encoder.encode(buffer));
+                }
+                buffer = "";
+            }
+        },
+    });
+    const outputStream = input.pipeThrough(transform);
+    return {
+        filtered: outputStream,
+        changeToken: () => token,
+    };
+}
+/**
+ * Check if an SSE block is a cashu-change event.
+ */
+function isCashuChangeBlock(block) {
+    // An SSE block with event: cashu-change
+    return /^event:\s*cashu-change\s*$/m.test(block);
+}

package/dist/proxy/types.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Shared type definitions for the proxy module.
+ */
+/**
+ * Logger interface for proxy operations.
+ */
+export interface Logger {
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+}
+/**
+ * Default console logger.
+ */
+export declare const defaultLogger: Logger;
+/**
+ * Known provider prefixes for model ID transformation.
+ * We use `-` as separator in OpenClaw to avoid double-slash issue,
+ * but Gate/OpenRouter expects `/` as separator.
+ */
+export declare const MODEL_PROVIDER_PREFIXES: readonly ["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"
+ */
+export declare function transformModelId(model: string): string;
+/**
+ * Parse Retry-After header value.
+ * Returns milliseconds to wait, or null if invalid.
+ */
+export declare function parseRetryAfter(value: string | null): number | null;
+/**
+ * Result from a proxy request.
+ */
+export interface ProxyResult {
+    status: number;
+    headers: Record<string, string>;
+    body: ReadableStream<Uint8Array> | string;
+}
+/**
+ * OpenAI chat completion request (minimal).
+ */
+export interface CompletionRequest {
+    model: string;
+    messages: Array<{
+        role: string;
+        content: string | unknown[];
+    }>;
+    stream?: boolean;
+    [key: string]: unknown;
+}
+/**
+ * Model info in OpenAI format.
+ */
+export interface ModelInfo {
+    id: string;
+    object: "model";
+    created: number;
+    owned_by: string;
+}
+/**
+ * Proxy handle returned by startProxy.
+ */
+export interface ProxyHandle {
+    stop: () => void;
+    proxySecret: string;
+}
+/**
+ * Payment result from token selection.
+ */
+export interface PaymentResult {
+    token: string;
+    priceSpent: number;
+    balanceAfter: number;
+}
+/**
+ * Change/refund received from Gate.
+ */
+export interface TokenReceiveResult {
+    amount: number;
+    type: "change" | "refund";
+}
+/**
+ * Proxy request metrics for a single request.
+ */
+export interface RequestMetrics {
+    txId: string;
+    model: string;
+    priceSat: number;
+    changeSat: number;
+    refundSat: number;
+    gateStatus: number;
+    balanceBefore: number;
+    balanceAfter: number;
+    durationMs: number;
+    error?: string;
+}
+/**
+ * Maximum request body size (10 MB).
+ */
+export declare const MAX_BODY_SIZE: number;
+/**
+ * Maximum retry delay (30 seconds).
+ */
+export declare const MAX_RETRY_DELAY_MS = 30000;
+/**
+ * Default retry configuration.
+ */
+export declare const DEFAULT_RETRY_CONFIG: {
+    readonly maxRetries: 2;
+    readonly baseDelayMs: 2000;
+    readonly maxDelayMs: 30000;
+};

package/dist/proxy/types.js

@@ -0,0 +1,74 @@
+/**
+ * Shared type definitions for the proxy module.
+ */
+/**
+ * Default console logger.
+ */
+export 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.
+ */
+export 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"
+ */
+export function transformModelId(model) {
+    for (const prefix of MODEL_PROVIDER_PREFIXES) {
+        if (model.startsWith(`${prefix}-`)) {
+            return `${prefix}/${model.slice(prefix.length + 1)}`;
+        }
+    }
+    return model;
+}
+/**
+ * Parse Retry-After header value.
+ * Returns milliseconds to wait, or null if invalid.
+ */
+export 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;
+}
+/**
+ * Maximum request body size (10 MB).
+ */
+export const MAX_BODY_SIZE = 10 * 1024 * 1024;
+/**
+ * Maximum retry delay (30 seconds).
+ */
+export const MAX_RETRY_DELAY_MS = 30_000;
+/**
+ * Default retry configuration.
+ */
+export const DEFAULT_RETRY_CONFIG = {
+    maxRetries: 2,
+    baseDelayMs: 2000,
+    maxDelayMs: MAX_RETRY_DELAY_MS,
+};

package/dist/proxy.d.ts

@@ -1,11 +1,4 @@
 import { type T2CConfig } from "./config.js";
-export interface Logger {
-    info: (...args: unknown[]) => void;
-    warn: (...args: unknown[]) => void;
-    error: (...args: unknown[]) => void;
-}
-export interface ProxyHandle {
-    stop: () => void;
-    proxySecret: string;
-}
+import { type Logger, type ProxyHandle, transformModelId, parseRetryAfter } from "./proxy/index.js";
+export { transformModelId, parseRetryAfter, type Logger, type ProxyHandle };
 export declare function startProxy(config: T2CConfig, logger?: Logger): Promise<ProxyHandle>;

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", () => {