@blockrun/clawrouter 0.3.2 → 0.3.3

package/dist/index.d.ts

@@ -237,6 +237,103 @@ type RouterOptions = {
  */
 declare function route(prompt: string, systemPrompt: string | undefined, maxOutputTokens: number, options: RouterOptions): RoutingDecision;
 
+/**
+ * Balance Monitor for ClawRouter
+ *
+ * Monitors USDC balance on Base network with intelligent caching.
+ * Provides pre-request balance checks to prevent failed payments.
+ *
+ * Caching Strategy:
+ *   - TTL: 30 seconds (balance is cached to avoid excessive RPC calls)
+ *   - Optimistic deduction: after successful payment, subtract estimated cost from cache
+ *   - Invalidation: on payment failure, immediately refresh from RPC
+ */
+/** Balance thresholds in USDC smallest unit (6 decimals) */
+declare const BALANCE_THRESHOLDS: {
+    /** Low balance warning threshold: $1.00 */
+    readonly LOW_BALANCE_MICROS: 1000000n;
+    /** Effectively zero threshold: $0.0001 (covers dust/rounding) */
+    readonly ZERO_THRESHOLD: 100n;
+};
+/** Balance information returned by checkBalance() */
+type BalanceInfo = {
+    /** Raw balance in USDC smallest unit (6 decimals) */
+    balance: bigint;
+    /** Formatted balance as "$X.XX" */
+    balanceUSD: string;
+    /** True if balance < $1.00 */
+    isLow: boolean;
+    /** True if balance < $0.0001 (effectively zero) */
+    isEmpty: boolean;
+    /** Wallet address for funding instructions */
+    walletAddress: string;
+};
+/** Result from checkSufficient() */
+type SufficiencyResult = {
+    /** True if balance >= estimated cost */
+    sufficient: boolean;
+    /** Current balance info */
+    info: BalanceInfo;
+    /** If insufficient, the shortfall as "$X.XX" */
+    shortfall?: string;
+};
+/**
+ * Monitors USDC balance on Base network.
+ *
+ * Usage:
+ *   const monitor = new BalanceMonitor("0x...");
+ *   const info = await monitor.checkBalance();
+ *   if (info.isLow) console.warn("Low balance!");
+ */
+declare class BalanceMonitor {
+    private readonly client;
+    private readonly walletAddress;
+    /** Cached balance (null = not yet fetched) */
+    private cachedBalance;
+    /** Timestamp when cache was last updated */
+    private cachedAt;
+    constructor(walletAddress: string);
+    /**
+     * Check current USDC balance.
+     * Uses cache if valid, otherwise fetches from RPC.
+     */
+    checkBalance(): Promise<BalanceInfo>;
+    /**
+     * Check if balance is sufficient for an estimated cost.
+     *
+     * @param estimatedCostMicros - Estimated cost in USDC smallest unit (6 decimals)
+     */
+    checkSufficient(estimatedCostMicros: bigint): Promise<SufficiencyResult>;
+    /**
+     * Optimistically deduct estimated cost from cached balance.
+     * Call this after a successful payment to keep cache accurate.
+     *
+     * @param amountMicros - Amount to deduct in USDC smallest unit
+     */
+    deductEstimated(amountMicros: bigint): void;
+    /**
+     * Invalidate cache, forcing next checkBalance() to fetch from RPC.
+     * Call this after a payment failure to get accurate balance.
+     */
+    invalidate(): void;
+    /**
+     * Force refresh balance from RPC (ignores cache).
+     */
+    refresh(): Promise<BalanceInfo>;
+    /**
+     * Format USDC amount (in micros) as "$X.XX".
+     */
+    formatUSDC(amountMicros: bigint): string;
+    /**
+     * Get the wallet address being monitored.
+     */
+    getWalletAddress(): string;
+    /** Fetch balance from RPC */
+    private fetchBalance;
+    /** Build BalanceInfo from raw balance */
+    private buildInfo;
+}
+
 /**
  * Local x402 Proxy Server
  *
@@ -260,11 +357,24 @@ declare function route(prompt: string, systemPrompt: string | undefined, maxOutp
  *   - Usage logging: log every request as JSON line to ~/.openclaw/blockrun/logs/
  */
 
+/** Callback info for low balance warning */
+type LowBalanceInfo = {
+    balanceUSD: string;
+    walletAddress: string;
+};
+/** Callback info for insufficient funds error */
+type InsufficientFundsInfo = {
+    balanceUSD: string;
+    requiredUSD: string;
+    walletAddress: string;
+};
 type ProxyOptions = {
     walletKey: string;
     apiBase?: string;
     port?: number;
     routingConfig?: Partial<RoutingConfig>;
+    /** Request timeout in ms (default: 180000 = 3 minutes). Covers on-chain tx + LLM response. */
+    requestTimeoutMs?: number;
     onReady?: (port: number) => void;
     onError?: (error: Error) => void;
     onPayment?: (info: {
@@ -273,10 +383,16 @@ type ProxyOptions = {
         network: string;
     }) => void;
     onRouted?: (decision: RoutingDecision) => void;
+    /** Called when balance drops below $1.00 (warning, request still proceeds) */
+    onLowBalance?: (info: LowBalanceInfo) => void;
+    /** Called when balance is insufficient for a request (request fails) */
+    onInsufficientFunds?: (info: InsufficientFundsInfo) => void;
 };
 type ProxyHandle = {
     port: number;
     baseUrl: string;
+    walletAddress: string;
+    balanceMonitor: BalanceMonitor;
     close: () => Promise<void>;
 };
 /**
@@ -446,6 +562,102 @@ type PaymentFetchResult = {
  */
 declare function createPaymentFetch(privateKey: `0x${string}`): PaymentFetchResult;
 
+/**
+ * Typed Error Classes for ClawRouter
+ *
+ * Provides structured errors for balance-related failures with
+ * all necessary information for user-friendly error messages.
+ */
+/**
+ * Thrown when wallet has insufficient USDC balance for a request.
+ */
+declare class InsufficientFundsError extends Error {
+    readonly code: "INSUFFICIENT_FUNDS";
+    readonly currentBalanceUSD: string;
+    readonly requiredUSD: string;
+    readonly walletAddress: string;
+    constructor(opts: {
+        currentBalanceUSD: string;
+        requiredUSD: string;
+        walletAddress: string;
+    });
+}
+/**
+ * Thrown when wallet has no USDC balance (or effectively zero).
+ */
+declare class EmptyWalletError extends Error {
+    readonly code: "EMPTY_WALLET";
+    readonly walletAddress: string;
+    constructor(walletAddress: string);
+}
+/**
+ * Type guard to check if an error is InsufficientFundsError.
+ */
+declare function isInsufficientFundsError(error: unknown): error is InsufficientFundsError;
+/**
+ * Type guard to check if an error is EmptyWalletError.
+ */
+declare function isEmptyWalletError(error: unknown): error is EmptyWalletError;
+/**
+ * Type guard to check if an error is a balance-related error.
+ */
+declare function isBalanceError(error: unknown): error is InsufficientFundsError | EmptyWalletError;
+/**
+ * Thrown when RPC call fails (network error, node down, etc).
+ * Distinguishes infrastructure failures from actual empty wallets.
+ */
+declare class RpcError extends Error {
+    readonly code: "RPC_ERROR";
+    readonly originalError: unknown;
+    constructor(message: string, originalError?: unknown);
+}
+/**
+ * Type guard to check if an error is RpcError.
+ */
+declare function isRpcError(error: unknown): error is RpcError;
+
+/**
+ * Retry Logic for ClawRouter
+ *
+ * Provides fetch wrapper with exponential backoff for transient errors.
+ * Retries on 429 (rate limit), 502, 503, 504 (server errors).
+ */
+/** Configuration for retry behavior */
+type RetryConfig = {
+    /** Maximum number of retries (default: 2) */
+    maxRetries: number;
+    /** Base delay in ms for exponential backoff (default: 500) */
+    baseDelayMs: number;
+    /** HTTP status codes that trigger a retry (default: [429, 502, 503, 504]) */
+    retryableCodes: number[];
+};
+/** Default retry configuration */
+declare const DEFAULT_RETRY_CONFIG: RetryConfig;
+/**
+ * Wrap a fetch-like function with retry logic and exponential backoff.
+ *
+ * @param fetchFn - The fetch function to wrap (can be standard fetch or x402 payFetch)
+ * @param url - URL to fetch
+ * @param init - Fetch init options
+ * @param config - Retry configuration (optional, uses defaults)
+ * @returns Response from successful fetch or last failed attempt
+ *
+ * @example
+ * ```typescript
+ * const response = await fetchWithRetry(
+ *   fetch,
+ *   "https://api.example.com/endpoint",
+ *   { method: "POST", body: JSON.stringify(data) },
+ *   { maxRetries: 3 }
+ * );
+ * ```
+ */
+declare function fetchWithRetry(fetchFn: (url: string, init?: RequestInit) => Promise<Response>, url: string, init?: RequestInit, config?: Partial<RetryConfig>): Promise<Response>;
+/**
+ * Check if an error or response indicates a retryable condition.
+ */
+declare function isRetryable(errorOrResponse: Error | Response, config?: Partial<RetryConfig>): boolean;
+
 /**
  * @blockrun/clawrouter
  *
@@ -459,12 +671,12 @@ declare function createPaymentFetch(privateKey: `0x${string}`): PaymentFetchResu
  *   # Fund your wallet with USDC on Base (address printed on install)
  *
  *   # Use smart routing (auto-picks cheapest model)
- *   openclaw config set model blockrun/auto
+ *   openclaw models set blockrun/auto
  *
  *   # Or use any specific BlockRun model
- *   openclaw config set model openai/gpt-5.2
+ *   openclaw models set openai/gpt-5.2
  */
 
 declare const plugin: OpenClawPluginDefinition;
 
-export { BLOCKRUN_MODELS, type CachedPaymentParams, type CachedResponse, DEFAULT_ROUTING_CONFIG, OPENCLAW_MODELS, PaymentCache, type PaymentFetchResult, type PreAuthParams, RequestDeduplicator, type RoutingConfig, type RoutingDecision, type Tier, type UsageEntry, blockrunProvider, buildProviderModels, createPaymentFetch, plugin as default, logUsage, route, startProxy };
+export { BALANCE_THRESHOLDS, BLOCKRUN_MODELS, type BalanceInfo, BalanceMonitor, type CachedPaymentParams, type CachedResponse, DEFAULT_RETRY_CONFIG, DEFAULT_ROUTING_CONFIG, EmptyWalletError, InsufficientFundsError, type InsufficientFundsInfo, type LowBalanceInfo, OPENCLAW_MODELS, PaymentCache, type PaymentFetchResult, type PreAuthParams, type ProxyHandle, type ProxyOptions, RequestDeduplicator, type RetryConfig, type RoutingConfig, type RoutingDecision, RpcError, type SufficiencyResult, type Tier, type UsageEntry, blockrunProvider, buildProviderModels, createPaymentFetch, plugin as default, fetchWithRetry, isBalanceError, isEmptyWalletError, isInsufficientFundsError, isRetryable, isRpcError, logUsage, route, startProxy };