@bridgenode/llm 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,3210 @@
+import * as _anthropic_ai_sdk from '@anthropic-ai/sdk';
+
+/**
+ * Type definitions for BlockRun LLM SDK
+ */
+interface FunctionDefinition {
+    name: string;
+    description?: string;
+    parameters?: Record<string, unknown>;
+    strict?: boolean;
+}
+interface Tool {
+    type: "function";
+    function: FunctionDefinition;
+}
+interface FunctionCall {
+    name: string;
+    arguments: string;
+}
+interface ToolCall {
+    id: string;
+    type: "function";
+    function: FunctionCall;
+}
+type ToolChoice = "none" | "auto" | "required" | {
+    type: "function";
+    function: {
+        name: string;
+    };
+};
+interface ChatMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content?: string | null;
+    name?: string;
+    tool_call_id?: string;
+    tool_calls?: ToolCall[];
+    reasoning_content?: string;
+    thinking?: string;
+}
+interface ChatChoice {
+    index: number;
+    message: ChatMessage;
+    finish_reason?: "stop" | "length" | "content_filter" | "tool_calls";
+}
+interface ChatUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+    num_sources_used?: number;
+    cache_read_input_tokens?: number;
+    cache_creation_input_tokens?: number;
+}
+interface ChatResponse {
+    id: string;
+    object: string;
+    created: number;
+    model: string;
+    choices: ChatChoice[];
+    usage?: ChatUsage;
+    citations?: string[];
+    /**
+     * Populated when the gateway transparently substituted a different
+     * model for the one the caller asked for — typically because the
+     * requested model errored and the gateway routed to a free fallback
+     * to fulfil the request. When `used` is true:
+     *   - `model` is the model that actually answered (vs `ChatResponse.model`
+     *     which historically reflected the requested model id).
+     *   - `settlementSkipped` is `true` when the gateway also skipped the
+     *     on-chain settle — i.e. the user was not charged for this call
+     *     because a free fallback served it.
+     * Surfaced from the gateway's `X-Fallback-Used / X-Fallback-Model /
+     * X-Settlement-Skipped` response headers. Absent when the headers
+     * aren't present (most calls).
+     */
+    fallback?: {
+        used: true;
+        model?: string;
+        settlementSkipped?: boolean;
+    };
+}
+interface Model {
+    id: string;
+    name: string;
+    provider: string;
+    description: string;
+    /** Per 1M tokens. 0 when billingMode !== "paid". */
+    inputPrice: number;
+    /** Per 1M tokens. 0 when billingMode !== "paid". */
+    outputPrice: number;
+    contextWindow: number;
+    maxOutput: number;
+    categories: string[];
+    available: boolean;
+    type?: "llm" | "image";
+    /** One of "paid" (per-token), "flat" (flatPrice per request) or "free". */
+    billingMode?: "paid" | "flat" | "free";
+    /** Flat per-request price when billingMode === "flat". */
+    flatPrice?: number;
+    /** True for deprecated/superseded models that remain routable. */
+    hidden?: boolean;
+}
+interface ImageData {
+    url: string;
+    /** Original upstream URL (e.g. imgen.x.ai). Omitted for data URIs. */
+    source_url?: string;
+    /** True when the gateway mirrored the image to its GCS bucket. Omitted for data URIs. */
+    backed_up?: boolean;
+    revised_prompt?: string;
+    b64_json?: string;
+}
+interface ImageResponse {
+    created: number;
+    data: ImageData[];
+}
+interface ImageModel {
+    id: string;
+    name: string;
+    provider: string;
+    description: string;
+    pricePerImage: number;
+    supportedSizes?: string[];
+    maxPromptLength?: number;
+    available: boolean;
+    type?: "llm" | "image";
+}
+interface ImageClientOptions {
+    /** EVM wallet private key (hex string starting with 0x) */
+    privateKey?: `0x${string}` | string;
+    /** API endpoint URL (default: https://bridgenode.cc/api) */
+    apiUrl?: string;
+    /** Request timeout in milliseconds (default: 120000 for images) */
+    timeout?: number;
+}
+interface ImageGenerateOptions {
+    /** Model ID (default: "google/nano-banana") */
+    model?: string;
+    /** Image size (default: "1024x1024") */
+    size?: string;
+    /** Number of images to generate (default: 1) */
+    n?: number;
+    /** Image quality (for supported models) */
+    quality?: "standard" | "hd";
+}
+interface WebSearchSource {
+    type: "web";
+    country?: string;
+    excludedWebsites?: string[];
+    allowedWebsites?: string[];
+    safeSearch?: boolean;
+}
+interface XSearchSource {
+    type: "x";
+    includedXHandles?: string[];
+    excludedXHandles?: string[];
+    postFavoriteCount?: number;
+    postViewCount?: number;
+}
+interface NewsSearchSource {
+    type: "news";
+    country?: string;
+    excludedWebsites?: string[];
+    allowedWebsites?: string[];
+    safeSearch?: boolean;
+}
+interface RssSearchSource {
+    type: "rss";
+    links: string[];
+}
+type SearchSource = WebSearchSource | XSearchSource | NewsSearchSource | RssSearchSource;
+interface SearchParameters {
+    mode?: "off" | "auto" | "on";
+    sources?: SearchSource[];
+    returnCitations?: boolean;
+    fromDate?: string;
+    toDate?: string;
+    maxSearchResults?: number;
+}
+/** Usage info for Live Search sources */
+interface SearchUsage {
+    /** Number of search sources used in the response */
+    numSourcesUsed?: number;
+}
+interface Spending {
+    totalUsd: number;
+    calls: number;
+}
+/** Pre-request cost estimate for a chat call */
+interface CostEstimate {
+    /** Model ID used for the estimate */
+    model: string;
+    /** Estimated input token count */
+    estimatedInputTokens: number;
+    /** Estimated output token count */
+    estimatedOutputTokens: number;
+    /** Estimated cost in USD */
+    estimatedCostUsd: number;
+}
+/** Per-call spending report with running session totals */
+interface SpendingReport {
+    /** Model ID used */
+    model: string;
+    /** Input tokens consumed */
+    inputTokens: number;
+    /** Output tokens consumed */
+    outputTokens: number;
+    /** Cost of this call in USD */
+    costUsd: number;
+    /** Cumulative session spend in USD */
+    sessionTotalUsd: number;
+    /** Total number of calls in this session */
+    sessionCalls: number;
+}
+/** Chat response bundled with its spending report */
+interface ChatResponseWithCost {
+    /** The chat completion response */
+    response: ChatResponse;
+    /** Spending report for this call */
+    spendingReport: SpendingReport;
+}
+interface ResourceInfo {
+    url: string;
+    description?: string;
+    mimeType?: string;
+}
+interface PaymentRequirement {
+    scheme: string;
+    network: string;
+    asset: string;
+    amount?: string;
+    maxAmountRequired?: string;
+    payTo: string;
+    maxTimeoutSeconds?: number;
+    extra?: {
+        name?: string;
+        version?: string;
+    };
+}
+interface PaymentRequired {
+    x402Version: number;
+    accepts: PaymentRequirement[];
+    resource?: ResourceInfo;
+}
+interface LLMClientOptions {
+    /** EVM wallet private key (hex string starting with 0x). Optional if BASE_CHAIN_WALLET_KEY env var is set. */
+    privateKey?: `0x${string}` | string;
+    /** API endpoint URL (default: https://bridgenode.cc/api) */
+    apiUrl?: string;
+    /** Request timeout in milliseconds (default: 600000 / 600s; override via BRIDGENODE_CHAT_TIMEOUT env, in seconds) */
+    timeout?: number;
+}
+/**
+ * OpenAI-compatible response format. `{ type: "json_object" }` enables JSON
+ * mode — honored across all providers by the gateway (native for OpenAI/Azure,
+ * emulated via a raw-JSON system instruction for Anthropic/Bedrock).
+ */
+type ResponseFormat = {
+    type: "text";
+} | {
+    type: "json_object";
+} | {
+    type: "json_schema";
+    json_schema: Record<string, unknown>;
+};
+interface ChatOptions {
+    /** System prompt */
+    system?: string;
+    /** Max tokens to generate */
+    maxTokens?: number;
+    /** Sampling temperature */
+    temperature?: number;
+    /** Nucleus sampling parameter */
+    topP?: number;
+    /** Enable Live Search (shortcut for searchParameters.mode = "on") */
+    search?: boolean;
+    /** Full Live Search configuration (for search-enabled models) */
+    searchParameters?: SearchParameters;
+    /** Response format, e.g. { type: "json_object" } for JSON mode */
+    responseFormat?: ResponseFormat;
+    /** Up to 4 stop sequences (forwarded natively / mapped to stop_sequences) */
+    stop?: string | string[];
+    /**
+     * Models to try in order if the primary returns a transient error
+     * (timeout, network, 5xx). 4xx and PaymentError still propagate
+     * immediately. `smartChat` populates this from the routing tier's
+     * fallback chain automatically.
+     */
+    fallbackModels?: string[];
+}
+interface ChatCompletionOptions {
+    /** Max tokens to generate */
+    maxTokens?: number;
+    /** Sampling temperature */
+    temperature?: number;
+    /** Nucleus sampling parameter */
+    topP?: number;
+    /** Enable Live Search (shortcut for searchParameters.mode = "on") */
+    search?: boolean;
+    /** Full Live Search configuration (for search-enabled models) */
+    searchParameters?: SearchParameters;
+    /** Tool definitions for function calling */
+    tools?: Tool[];
+    /** Tool selection strategy */
+    toolChoice?: ToolChoice;
+    /** Response format, e.g. { type: "json_object" } for JSON mode */
+    responseFormat?: ResponseFormat;
+    /** Up to 4 stop sequences (forwarded natively / mapped to stop_sequences) */
+    stop?: string | string[];
+    /**
+     * Models to try in order if the primary returns a transient error
+     * (timeout, network, 5xx). 4xx and PaymentError still propagate
+     * immediately.
+     */
+    fallbackModels?: string[];
+}
+type RoutingProfile = "eco" | "auto" | "premium";
+type RoutingTier = "SIMPLE" | "MEDIUM" | "COMPLEX" | "REASONING";
+interface RoutingDecision {
+    model: string;
+    tier: RoutingTier;
+    confidence: number;
+    method: "rules" | "llm";
+    reasoning: string;
+    costEstimate: number;
+    baselineCost: number;
+    savings: number;
+    /** Routing profile applied by clawrouter (may include "agentic" on gateway responses). */
+    profile?: RoutingProfile | "agentic";
+    /** Score used when agentic routing is active. */
+    agenticScore?: number;
+    /**
+     * Remaining tier models with known pricing, in fallback order. `chat()`
+     * walks this list when the primary model hits a transient error
+     * (timeout, network, 5xx). Excludes the primary itself.
+     */
+    fallbacks?: string[];
+}
+interface SmartChatOptions extends ChatOptions {
+    /** Routing profile: eco (budget), auto (balanced), premium (best quality) */
+    routingProfile?: RoutingProfile;
+    /** Maximum output tokens (used for cost estimation) */
+    maxOutputTokens?: number;
+}
+interface SmartChatResponse {
+    /** The AI response text */
+    response: string;
+    /** Which model was selected by smart routing */
+    model: string;
+    /** Routing decision metadata */
+    routing: RoutingDecision;
+}
+interface SearchResult {
+    query: string;
+    summary: string;
+    citations?: Array<Record<string, string>>;
+    sources_used?: number;
+    model?: string;
+}
+interface ImageEditOptions {
+    /** Model ID (default: "openai/gpt-image-2") */
+    model?: string;
+    /** Optional base64-encoded mask image */
+    mask?: string;
+    /** Image size (default: "1024x1024") */
+    size?: string;
+    /** Number of images to generate (default: 1) */
+    n?: number;
+}
+interface AudioTrack {
+    url: string;
+    duration_seconds?: number;
+    lyrics?: string;
+}
+interface MusicResponse {
+    created: number;
+    model: string;
+    data: AudioTrack[];
+    txHash?: string;
+}
+interface AudioModel {
+    id: string;
+    name: string;
+    provider: string;
+    description: string;
+    pricePerTrack: number;
+    maxDurationSeconds: number;
+    supportsLyrics: boolean;
+    supportsInstrumental: boolean;
+    available: boolean;
+    type: "audio";
+}
+interface MusicClientOptions {
+    /** EVM wallet private key (hex string starting with 0x) */
+    privateKey?: `0x${string}` | string;
+    /** API endpoint URL (default: https://bridgenode.cc/api) */
+    apiUrl?: string;
+    /** Request timeout in milliseconds (default: 210000 — music gen takes 1-3 min) */
+    timeout?: number;
+}
+interface MusicGenerateOptions {
+    /** Model ID (default: "minimax/music-2.5+") */
+    model?: "minimax/music-2.5+" | "minimax/music-2.5";
+    /** Generate without vocals (default: true) */
+    instrumental?: boolean;
+    /** Custom lyrics — cannot be used with instrumental: true */
+    lyrics?: string;
+}
+/** A single synthesized audio clip. */
+interface SpeechAudio {
+    url: string;
+    format?: string;
+    characters?: number;
+    credits?: number;
+}
+/** Response from speech synthesis or sound-effect generation. */
+interface SpeechResponse {
+    created: number;
+    model: string;
+    data: SpeechAudio[];
+    txHash?: string;
+}
+interface SpeechClientOptions {
+    /** EVM wallet private key (hex string starting with 0x) */
+    privateKey?: `0x${string}` | string;
+    /** API endpoint URL (default: https://bridgenode.cc/api) */
+    apiUrl?: string;
+    /** Request timeout in milliseconds (default: 120000 — synthesis is synchronous) */
+    timeout?: number;
+}
+/** TTS model IDs (price per 1k chars: flash/turbo $0.05, multilingual-v2/v3 $0.10). */
+type SpeechModel = "elevenlabs/flash-v2.5" | "elevenlabs/turbo-v2.5" | "elevenlabs/multilingual-v2" | "elevenlabs/v3";
+/** Friendly voice aliases (raw ElevenLabs voice_ids also accepted). */
+type SpeechVoice = "sarah" | "george" | "laura" | "charlie" | "river" | "roger" | "callum" | "harry" | (string & {});
+interface SpeechGenerateOptions {
+    /** Speech model ID (default: "elevenlabs/flash-v2.5") */
+    model?: SpeechModel | (string & {});
+    /** Voice alias or raw ElevenLabs voice_id (default: "sarah") */
+    voice?: SpeechVoice;
+    /** Audio format (default: "mp3") */
+    responseFormat?: "mp3" | "opus" | "pcm" | "wav";
+    /** Playback speed 0.7-1.2 */
+    speed?: number;
+}
+interface SoundEffectOptions {
+    /** Model ID (default: "elevenlabs/sound-effects") */
+    model?: string;
+    /** Target duration 0.5-22s (auto if unset) */
+    durationSeconds?: number;
+    /** 0-1, higher follows the prompt more literally */
+    promptInfluence?: number;
+    /** Audio format (default: "mp3") */
+    responseFormat?: "mp3" | "opus" | "pcm" | "wav";
+}
+/** A voice entry returned by GET /v1/audio/voices. */
+interface VoiceInfo {
+    voice_id: string;
+    name?: string;
+    alias?: string;
+    category?: string;
+    labels?: Record<string, string>;
+    preview_url?: string;
+    [key: string]: unknown;
+}
+interface RpcClientOptions {
+    /** EVM wallet private key (hex string starting with 0x) */
+    privateKey?: `0x${string}` | string;
+    /** API endpoint URL (default: https://bridgenode.cc/api) */
+    apiUrl?: string;
+    /** Request timeout in milliseconds (default: 60000 — upstream gateway timeout is 20s) */
+    timeout?: number;
+}
+/** A JSON-RPC 2.0 error object. */
+interface RpcError {
+    code?: number;
+    message?: string;
+    data?: unknown;
+}
+/**
+ * Response from a multi-chain JSON-RPC call.
+ *
+ * Standard JSON-RPC 2.0 envelope plus BlockRun gateway metadata pulled
+ * from response headers (PAYMENT-RESPONSE / X-Network / X-Cache).
+ */
+interface RpcResponse<T = unknown> {
+    jsonrpc?: string;
+    id?: string | number | null;
+    result?: T;
+    error?: RpcError;
+    /** Canonical network key, e.g. "ethereum" (from X-Network) */
+    network?: string;
+    /** Served from the gateway's method-aware cache (from X-Cache) */
+    cacheHit?: boolean;
+    /** x402 settlement tx hash (single calls) */
+    txHash?: string;
+}
+/** A single request in a JSON-RPC batch (jsonrpc/id auto-filled if omitted). */
+interface RpcBatchRequest {
+    method: string;
+    params?: unknown[];
+    id?: string | number;
+    jsonrpc?: string;
+}
+/** Built-in Bland.ai voice presets. Any string is accepted (custom voice IDs work too). */
+type VoicePreset = "nat" | "josh" | "maya" | "june" | "paige" | "derek" | "florian";
+/** Bland.ai conversation model tier. */
+type CallModel = "base" | "enhanced" | "turbo";
+interface VoiceClientOptions {
+    /** EVM wallet private key (hex string starting with 0x) */
+    privateKey?: `0x${string}` | string;
+    /** API endpoint URL (default: https://bridgenode.cc/api) */
+    apiUrl?: string;
+    /** Request timeout in milliseconds (default: 60000 — initiation only) */
+    timeout?: number;
+}
+interface CallOptions {
+    /** Destination phone number in E.164 format (e.g. "+14155552671"). US + Canada. */
+    to: string;
+    /** What the AI agent should do on the call. 10–4000 chars. */
+    task: string;
+    /** Your provisioned BlockRun caller-ID number (E.164). Must be wallet-owned. */
+    from?: string;
+    /** Voice preset or any Bland.ai voice ID. */
+    voice?: VoicePreset | string;
+    /** Maximum call length in minutes (1–30, default 5). */
+    max_duration?: number;
+    /** BCP-47 language code for STT/TTS (default "en-US"). */
+    language?: string;
+    /** Optional opening line spoken by the agent. */
+    first_sentence?: string;
+    /** If true, wait for the recipient to speak first. */
+    wait_for_greeting?: boolean;
+    /** Sensitivity for detecting recipient interruption (50–500 ms). */
+    interruption_threshold?: number;
+    /** Conversation model. */
+    model?: CallModel;
+}
+interface CallInitiatedResponse {
+    call_id: string;
+    status: string;
+    poll_url: string;
+    message?: string;
+    /** On-chain payment receipt (Base tx hash). */
+    txHash?: string;
+}
+/**
+ * Bland.ai call status payload. Returned from getStatus.
+ * Most fields are populated only after the call ends.
+ */
+interface CallStatusResponse {
+    call_id?: string;
+    status?: string;
+    to?: string;
+    from?: string;
+    /** ISO timestamp call started, or null while queued. */
+    started_at?: string | null;
+    /** ISO timestamp call ended, or null while in progress. */
+    ended_at?: string | null;
+    /** Total call length in seconds, once completed. */
+    call_length?: number;
+    /** URL to the call recording (mp3/wav). */
+    recording_url?: string | null;
+    /** Full text transcript of the call. */
+    concatenated_transcript?: string | null;
+    /** Per-turn transcript array. Shape comes from Bland.ai. */
+    transcripts?: Array<Record<string, unknown>>;
+    /** Why the call ended ("user_hangup", "agent_hangup", "timeout", …). */
+    ended_reason?: string | null;
+    /** Pass-through for anything Bland.ai adds. */
+    [key: string]: unknown;
+}
+interface VideoClip {
+    /** Permanent blockrun-hosted URL (falls back to upstream if backup fails) */
+    url: string;
+    /** Original upstream URL (e.g. vidgen.x.ai) */
+    source_url?: string;
+    /** Duration of the generated video */
+    duration_seconds?: number;
+    /** Upstream provider's request id (xAI) */
+    request_id?: string;
+    /** True when the gateway mirrored the video to its GCS bucket */
+    backed_up?: boolean;
+}
+interface VideoResponse {
+    created: number;
+    model: string;
+    data: VideoClip[];
+    txHash?: string;
+}
+interface VideoModel {
+    id: string;
+    name: string;
+    provider: string;
+    description: string;
+    pricePerSecond: number;
+    defaultDurationSeconds: number;
+    maxDurationSeconds: number;
+    supportsImageInput: boolean;
+    available: boolean;
+    type: "video";
+}
+interface VideoClientOptions {
+    /** EVM wallet private key (hex string starting with 0x) */
+    privateKey?: `0x${string}` | string;
+    /** API endpoint URL (default: https://bridgenode.cc/api) */
+    apiUrl?: string;
+    /** Request timeout in milliseconds (default: 300000 — video gen + polling up to 3 min) */
+    timeout?: number;
+}
+interface VideoGenerateOptions {
+    /** Model ID (default: "xai/grok-imagine-video") */
+    model?: "xai/grok-imagine-video" | string;
+    /** Optional seed image URL for image-to-video */
+    imageUrl?: string;
+    /**
+     * Virtual Portrait asset ID (`ta_xxxxxx`) — keeps the same AI character
+     * across multiple Seedance videos. Enroll via `POST /v1/portrait/enroll`
+     * ($0.01 USDC promo, no KYC). **Seedance 2.0 fast/pro only.** Mutually exclusive
+     * with `imageUrl`. Real-person likeness is not supported on BlockRun.
+     */
+    realFaceAssetId?: string;
+    /**
+     * First-and-last-frame interpolation: a second image that seeds the FINAL
+     * frame so the model tweens from `imageUrl` → `lastFrameUrl`. Requires
+     * `imageUrl` (the first frame) and a Seedance model
+     * (bytedance/seedance-1.5-pro, seedance-2.0, or seedance-2.0-fast).
+     * Priced identically to image-to-video. Mutually exclusive with
+     * `realFaceAssetId`.
+     */
+    lastFrameUrl?: string;
+    /**
+     * Omni / multi-reference: up to 9 reference image URLs for character/style
+     * consistency (**Seedance 2.0 only**). Cite them as "image 1", "image 2"
+     * in the prompt. Mutually exclusive with `imageUrl` / `lastFrameUrl` /
+     * `realFaceAssetId`.
+     */
+    referenceImageUrls?: string[];
+    /** Duration to bill for (defaults to model's default duration) */
+    durationSeconds?: number;
+    /** Output aspect ratio. Token360 / Seedance only — silently ignored by xAI Grok. */
+    aspectRatio?: "adaptive" | "16:9" | "9:16" | "1:1" | "4:3" | "3:4" | "21:9" | "9:21";
+    /** Output resolution. Token360 / Seedance only. */
+    resolution?: "360p" | "480p" | "540p" | "720p" | "1080p" | "1K" | "2K" | "4K";
+    /**
+     * Whether the model should produce a synced audio track. Token360 / Seedance
+     * only — silently ignored by xAI Grok. When omitted, the gateway defaults to
+     * `true` for text-to-video and `false` for image- or face-conditioned
+     * generation (the t2v / i2v split that matches Token360's quality profile).
+     * Pass an explicit boolean to override. Audio generation may be a paid
+     * surcharge upstream, so callers should expose this as a visible toggle.
+     */
+    generateAudio?: boolean;
+    /** Reproducibility seed when supported by the model. */
+    seed?: number;
+    /** Embed the upstream watermark on the output. Defaults to false at the gateway. */
+    watermark?: boolean;
+    /** Return the last frame as an image alongside the clip — useful for chaining. */
+    returnLastFrame?: boolean;
+}
+interface SearchOptions {
+    /** Source types to search (e.g. ["web", "x", "news"]) */
+    sources?: string[];
+    /** Maximum number of results (default: 10) */
+    maxResults?: number;
+    /** Start date filter (YYYY-MM-DD) */
+    fromDate?: string;
+    /** End date filter (YYYY-MM-DD) */
+    toDate?: string;
+}
+interface ExaSearchOptions {
+    /** Number of results to return (default: 10, max: 100) */
+    numResults?: number;
+    /** Restrict to a content category */
+    category?: "github" | "news" | "research paper" | "linkedin profile" | "personal site" | "tweet" | "financial report" | "pdf" | "company";
+    /** Only include pages published after this date (ISO 8601) */
+    startPublishedDate?: string;
+    /** Only include pages published before this date (ISO 8601) */
+    endPublishedDate?: string;
+    /** Only search within these domains */
+    includeDomains?: string[];
+    /** Exclude these domains from results */
+    excludeDomains?: string[];
+}
+interface ExaSearchItem {
+    id: string;
+    url: string;
+    title: string;
+    publishedDate?: string;
+    author?: string;
+    score?: number;
+}
+interface ExaSearchResponse {
+    requestId: string;
+    resolvedSearchType: string;
+    results: ExaSearchItem[];
+    searchTime: number;
+    costDollars: {
+        total: number;
+    };
+}
+interface ExaAnswerCitation {
+    id: string;
+    title: string;
+    url: string;
+    publishedDate?: string;
+    favicon?: string;
+}
+interface ExaAnswerResponse {
+    requestId: string;
+    answer: string;
+    citations: ExaAnswerCitation[];
+}
+interface ExaContentItem {
+    id: string;
+    url: string;
+    title: string;
+    text: string;
+    author?: string | null;
+}
+interface ExaContentsResponse {
+    results: ExaContentItem[];
+    costDollars: {
+        total: number;
+    };
+}
+interface ExaFindSimilarOptions {
+    /** Number of results to return (default: 10, max: 100) */
+    numResults?: number;
+    /** Exclude pages from the same domain as the reference URL */
+    excludeSourceDomain?: boolean;
+}
+interface OnrampResult {
+    /** One-time https://pay.coinbase.com/... URL prefilled for this wallet. */
+    url: string;
+}
+type PriceCategory = "crypto" | "fx" | "commodity" | "usstock" | "stocks";
+type StockMarket = "us" | "hk" | "jp" | "kr" | "gb" | "de" | "fr" | "nl" | "ie" | "lu" | "cn" | "ca";
+type BarResolution = "1" | "5" | "15" | "60" | "240" | "D" | "W" | "M";
+type MarketSession = "pre" | "post" | "on";
+interface PricePoint {
+    symbol: string;
+    price: number;
+    publishTime?: number;
+    confidence?: number;
+    feedId?: string;
+    timestamp?: string;
+    assetType?: string;
+    category?: string;
+    source?: string;
+    free?: boolean;
+}
+interface PriceBar {
+    t?: number;
+    o?: number;
+    h?: number;
+    l?: number;
+    c?: number;
+    v?: number;
+}
+interface PriceHistoryResponse {
+    symbol: string;
+    resolution?: string;
+    from?: number;
+    to?: number;
+    bars: PriceBar[];
+    source?: string;
+    category?: string;
+}
+interface SymbolListResponse {
+    symbols: Array<Record<string, unknown>>;
+    count?: number;
+}
+interface PriceOptions {
+    /** Required when category === "stocks". */
+    market?: StockMarket;
+    /** Optional US-equity session hint; ignored for non-equity. */
+    session?: MarketSession;
+}
+interface HistoryOptions extends PriceOptions {
+    /** TradingView-style bar resolution. Defaults to "D". */
+    resolution?: BarResolution;
+    /** Window start, unix seconds (required). */
+    from: number;
+    /** Window end, unix seconds. Defaults to now on the backend. */
+    to?: number;
+}
+interface ListOptions extends PriceOptions {
+    /** Free-text filter (maps to ?q=). */
+    query?: string;
+    /** Page size, capped at 2000. Defaults to 100. */
+    limit?: number;
+}
+interface SearchClientOptions {
+    privateKey?: `0x${string}` | string;
+    apiUrl?: string;
+    timeout?: number;
+}
+interface PriceClientOptions {
+    privateKey?: `0x${string}` | string;
+    apiUrl?: string;
+    timeout?: number;
+    /** If false, construction succeeds without a wallet (free endpoints only). */
+    requireWallet?: boolean;
+}
+interface SurfClientOptions {
+    privateKey?: `0x${string}` | string;
+    apiUrl?: string;
+    timeout?: number;
+}
+interface PhoneClientOptions {
+    /** EVM wallet private key (hex string starting with 0x) */
+    privateKey?: `0x${string}` | string;
+    /** API endpoint URL (default: https://bridgenode.cc/api) */
+    apiUrl?: string;
+    /** Request timeout in milliseconds (default: 600000 / 600s; override via BRIDGENODE_CHAT_TIMEOUT env, in seconds) */
+    timeout?: number;
+}
+/**
+ * Twilio Lookup passthrough — shape comes from upstream and varies by feature
+ * (basic vs `line_type_intelligence`, `sim_swap`, `call_forwarding`).
+ * Typed as a permissive record so future Twilio fields don't require an SDK release.
+ */
+interface PhoneLookupResponse {
+    phone_number?: string;
+    country_code?: string;
+    national_format?: string;
+    caller_name?: Record<string, unknown> | null;
+    carrier?: Record<string, unknown> | null;
+    line_type_intelligence?: Record<string, unknown> | null;
+    sim_swap?: Record<string, unknown> | null;
+    call_forwarding?: Record<string, unknown> | null;
+    /** Pass-through for anything Twilio adds. */
+    [key: string]: unknown;
+}
+interface PhoneBuyOptions {
+    /** ISO country code, "US" or "CA" (default "US"). */
+    country?: "US" | "CA";
+    /**
+     * Optional 3-digit area-code hint. Availability is not guaranteed — the
+     * backend falls back to any number in the country if the area code
+     * can't be matched.
+     */
+    areaCode?: string;
+}
+interface PhoneBuyResponse {
+    /** The E.164 number now bound to your wallet. */
+    phone_number: string;
+    /** ISO-8601 expiry (30 days out from purchase). */
+    expires_at: string;
+    /** "base" | "solana" — settlement chain. */
+    chain: string;
+    /** Human-readable note. */
+    message?: string;
+    /** On-chain payment receipt (tx hash). */
+    txHash?: string;
+}
+interface PhoneRenewResponse {
+    phone_number: string;
+    /** Extended expiry (30 days from previous expiry). */
+    expires_at: string;
+    txHash?: string;
+}
+interface PhoneNumberRecord {
+    phone_number: string;
+    chain: string;
+    expires_at: string;
+    active: boolean;
+}
+interface PhoneListResponse {
+    numbers: PhoneNumberRecord[];
+    count: number;
+    txHash?: string;
+}
+interface PhoneReleaseResponse {
+    released: true;
+    phone_number: string;
+    txHash?: string;
+}
+interface PortraitClientOptions {
+    /** EVM wallet private key (hex string starting with 0x) */
+    privateKey?: `0x${string}` | string;
+    /** API endpoint URL (default: https://bridgenode.cc/api) */
+    apiUrl?: string;
+    /** Request timeout in milliseconds (default: 600000 / 600s; override via BRIDGENODE_CHAT_TIMEOUT env, in seconds) */
+    timeout?: number;
+}
+interface PortraitEnrollOptions {
+    /** Display name for the portrait (1–64 chars). */
+    name: string;
+    /**
+     * Public HTTPS URL to a JPG/PNG/WEBP face image (≤10 MB). The gateway fetches
+     * it server-side and forwards it to Token360 as multipart — only the URL is sent.
+     */
+    imageUrl: string;
+}
+/**
+ * Response from `POST /v1/portrait/enroll`. The `asset_id` (`ta_xxxxxx`) is what
+ * you pass as `realFaceAssetId` on a Seedance 2.0 video generation to keep the
+ * same AI character across clips.
+ */
+interface PortraitEnrollResponse {
+    object: "virtual_portrait";
+    /** Token360 asset id (`ta_xxxxxx`) — pass as `realFaceAssetId` in VideoGenerateOptions. */
+    asset_id: string;
+    /** Token360 asset-group id (internal/debugging). */
+    group_id: string;
+    name: string;
+    /**
+     * Persisted thumbnail URL. The gateway mirrors your source image to its own
+     * storage when possible (so the listing thumbnail survives a dead source
+     * host); falls back to the original URL if mirroring fails. See `mirrored`.
+     */
+    image_url: string;
+    /** The original URL you supplied (before any mirroring). */
+    source_image_url?: string;
+    /** Whether `image_url` is the gateway-mirrored copy (true) or your original (false). */
+    mirrored?: boolean;
+    /** ISO-8601 creation timestamp. */
+    created_at: string;
+    usage: {
+        compatible_models: string[];
+        how_to_use: string;
+    };
+    price: {
+        amount: string;
+        currency: string;
+    };
+    settlement: {
+        success: boolean;
+        tx_hash: string | null;
+        network: string;
+    };
+    /** On-chain payment receipt (tx hash), surfaced from the response header. */
+    txHash?: string;
+}
+interface BridgeNodeClientOptions {
+    privateKey?: `0x${string}` | string;
+    apiUrl?: string;
+    /** Per-HTTP-call timeout in ms (default 60000). For long-running poll() jobs,
+     *  set budgetMs in PollOptions instead — this only bounds individual fetches. */
+    timeout?: number;
+}
+interface PollOptions {
+    /** Total wall-clock budget for the entire submit + poll loop (default 300000 = 5 min). */
+    budgetMs?: number;
+    /** Sleep between poll attempts (default 5000 = 5 s). */
+    intervalMs?: number;
+}
+declare class BridgeNodeError extends Error {
+    constructor(message: string);
+}
+declare class PaymentError extends BridgeNodeError {
+    constructor(message: string);
+}
+declare class APIError extends BridgeNodeError {
+    statusCode: number;
+    response?: unknown;
+    constructor(message: string, statusCode: number, response?: unknown);
+}
+
+/**
+ * BlockRun LLM Client - Main SDK entry point.
+ *
+ * Usage:
+ *   import { LLMClient } from '@blockrun/llm';
+ *
+ *   // Option 1: Use BASE_CHAIN_WALLET_KEY env var
+ *   const client = new LLMClient();
+ *
+ *   // Option 2: Pass private key directly
+ *   const client = new LLMClient({ privateKey: '0x...' });
+ *
+ *   const response = await client.chat('openai/gpt-5.2', 'Hello!');
+ *   console.log(response);
+ */
+
+/**
+ * BlockRun LLM Gateway Client.
+ *
+ * Provides access to multiple LLM providers (OpenAI, Anthropic, Google, etc.)
+ * with automatic x402 micropayments on Base chain (Mainnet, Chain ID 8453).
+ * API base: https://bridgenode.cc/api
+ */
+declare class LLMClient {
+    static readonly DEFAULT_API_URL = "https://bridgenode.cc/api";
+    private account;
+    private privateKey;
+    private apiUrl;
+    private timeout;
+    private sessionTotalUsd;
+    private sessionCalls;
+    private modelPricingCache;
+    private modelPricingPromise;
+    private preAuthCache;
+    private static readonly PRE_AUTH_TTL_MS;
+    /**
+     * Initialize the BlockRun LLM client.
+     *
+     * @param options - Client configuration options (optional if BASE_CHAIN_WALLET_KEY env var is set)
+     */
+    constructor(options?: LLMClientOptions);
+    /**
+     * Simple 1-line chat interface.
+     *
+     * @param model - Model ID (e.g., 'openai/gpt-5.2', 'anthropic/claude-sonnet-4.6')
+     * @param prompt - User message
+     * @param options - Optional chat parameters
+     * @returns Assistant's response text
+     *
+     * @example
+     * const response = await client.chat('gpt-5.2', 'What is the capital of France?');
+     * console.log(response); // 'The capital of France is Paris.'
+     */
+    chat(model: string, prompt: string, options?: ChatOptions): Promise<string>;
+    /**
+     * Smart chat with automatic model routing.
+     *
+     * Uses ClawRouter's 14-dimension rule-based scoring algorithm (<1ms, 100% local)
+     * to select the cheapest model that can handle your request.
+     *
+     * @param prompt - User message
+     * @param options - Optional chat and routing parameters
+     * @returns SmartChatResponse with response text, selected model, and routing metadata
+     *
+     * @example Simple usage (auto profile)
+     * ```ts
+     * const result = await client.smartChat('What is 2+2?');
+     * console.log(result.response); // '4'
+     * console.log(result.model); // 'google/gemini-2.5-flash-lite'
+     * console.log(result.routing.savings); // 0.78 (78% savings)
+     * ```
+     *
+     * @example With routing profile
+     * ```ts
+     * // Eco mode (budget optimized)
+     * const result = await client.smartChat('Explain quantum computing', { routingProfile: 'eco' });
+     *
+     * // Premium mode (best quality)
+     * const result = await client.smartChat('Write a business plan', { routingProfile: 'premium' });
+     * ```
+     */
+    smartChat(prompt: string, options?: SmartChatOptions): Promise<SmartChatResponse>;
+    /**
+     * Get model pricing map (cached).
+     * Fetches from API on first call, then returns cached result.
+     */
+    private getModelPricing;
+    /**
+     * Fetch model pricing from API.
+     *
+     * For flat-billed models (e.g. ZAI GLM-5 family at $0.001/call) the
+     * router still expects per-token rates, so we synthesise an equivalent
+     * per-token price assuming ~1500 total tokens per call. Without this,
+     * flat models would resolve to inputPrice=outputPrice=0 and the router
+     * would treat them as free, biasing routing decisions and reporting
+     * inflated savings %.
+     */
+    private fetchModelPricing;
+    /**
+     * Full chat completion interface (OpenAI-compatible).
+     *
+     * When `fallbackModels` is set, transient failures (timeouts, network
+     * errors, 5xx) on the primary model trigger a retry against the next
+     * model in the list before raising. 4xx errors and PaymentError
+     * propagate immediately — those aren't "swap upstream and retry"
+     * situations. Each fallback hop logs one stderr line.
+     *
+     * @param model - Primary model ID
+     * @param messages - Array of messages with role and content
+     * @param options - Optional completion parameters
+     * @returns ChatResponse object with choices and usage
+     */
+    chatCompletion(model: string, messages: ChatMessage[], options?: ChatCompletionOptions): Promise<ChatResponse>;
+    /**
+     * Write a canonical cost_log entry after a settled x402 payment.
+     * Best-effort: failures here must never break a successful API call.
+     * Mirrors what Franklin's AgentClient writes via src/agent/llm.ts so
+     * cost_log.jsonl is a single source of truth regardless of caller.
+     */
+    private recordCost;
+    /**
+     * Parse the chat response JSON and attach `fallback` metadata when the
+     * gateway signalled a transparent free-fallback substitution. The
+     * gateway sets X-Fallback-Used / X-Fallback-Model / X-Settlement-Skipped
+     * on the response when it served a paid request from a free model
+     * (route.ts createPaymentResponseHeader path). Without surfacing these
+     * to the caller, the user gets a different model than requested with
+     * no visibility — silent quality drop and no clue why the on-chain
+     * balance didn't change.
+     */
+    private parseChatResponse;
+    /**
+     * Make a request with automatic x402 payment handling.
+     */
+    private requestWithPayment;
+    /**
+     * Handle 402 response: parse requirements, sign payment, retry.
+     */
+    private handlePaymentAndRetry;
+    /**
+     * Sign a payment header and return the PAYMENT-SIGNATURE value.
+     * Extracted to share logic between streaming and non-streaming flows.
+     */
+    private signPayment;
+    /**
+     * Streaming chat completion with automatic x402 payment.
+     *
+     * Uses a pre-auth cache so repeat calls to the same model skip the 402
+     * round-trip (~200ms savings). Falls back to the normal 402 flow on cache
+     * miss or if the pre-signed payment is rejected.
+     *
+     * @returns Raw fetch Response with a streaming SSE body.
+     */
+    chatCompletionStream(model: string, messages: ChatMessage[], options?: ChatCompletionOptions): Promise<Response>;
+    /**
+     * Make a request with automatic x402 payment handling, returning raw JSON.
+     * Used for non-ChatResponse endpoints (X/Twitter, search, image edit, etc.).
+     */
+    private requestWithPaymentRaw;
+    /**
+     * Handle 402 response for raw endpoints: parse requirements, sign payment, retry.
+     */
+    private handlePaymentAndRetryRaw;
+    /**
+     * GET with automatic x402 payment handling, returning raw JSON.
+     * Used for Predexon prediction market endpoints that use GET + query params.
+     */
+    private getWithPaymentRaw;
+    /**
+     * Handle 402 response for GET endpoints: parse requirements, sign payment, retry with GET.
+     */
+    private handleGetPaymentAndRetryRaw;
+    /**
+     * Fetch with timeout.
+     */
+    private fetchWithTimeout;
+    /**
+     * List available models with pricing.
+     *
+     * Returns the full `/v1/models` unified catalog (chat + image + music).
+     * The shape preserves backwards compatibility — image/music rows have
+     * `inputPrice = outputPrice = 0` since those fields don't apply, and
+     * their per-call price surfaces via `flatPrice`.
+     */
+    listModels(): Promise<Model[]>;
+    /**
+     * List available image generation models with pricing.
+     *
+     * The dedicated `/v1/images/models` endpoint was deprecated server-side;
+     * image models live in the unified `/v1/models` catalog under
+     * `categories: ["image", ...]`. This method filters that catalog so
+     * existing callers keep working.
+     */
+    listImageModels(): Promise<ImageModel[]>;
+    /**
+     * List all available models (chat, image, music, etc.) with pricing.
+     *
+     * @returns Array of all models with `type` field set from category
+     * (`llm` for chat, `image` / `music` for media). Backwards-compat:
+     * chat models always report `type: "llm"`.
+     */
+    listAllModels(): Promise<(Model | ImageModel)[]>;
+    /**
+     * Internal: fetch the raw `/v1/models` catalog without normalising shape.
+     * Used by listImageModels / listAllModels so each can pick category-
+     * specific fields.
+     */
+    private fetchRawModels;
+    /**
+     * Edit an image using img2img, optionally fusing multiple source images.
+     *
+     * @param prompt - Text description of the desired edit
+     * @param image - A base64 `data:image/...` URI, or an array of 2–4 such URIs
+     *   to fuse (image fusion). Caps: `openai/*` up to 4, `google/*` up to 3.
+     *   A `mask` cannot be combined with multiple source images.
+     * @param options - Optional edit parameters
+     * @returns ImageResponse with edited image URLs
+     */
+    imageEdit(prompt: string, image: string | string[], options?: ImageEditOptions): Promise<ImageResponse>;
+    /**
+     * Standalone search (web, X/Twitter, news).
+     *
+     * @param query - Search query
+     * @param options - Optional search parameters
+     * @returns SearchResult with summary and citations
+     */
+    search(query: string, options?: SearchOptions): Promise<SearchResult>;
+    /**
+     * Generic Exa endpoint proxy (POST). Useful when you need an Exa API
+     * surface that the typed wrappers below don't expose.
+     *
+     * @param path - Exa endpoint segment: "search" | "find-similar" | "contents" | "answer"
+     * @param body - Request body (see Exa API docs)
+     *
+     * @example
+     * const results = await client.exa("search", { query: "latest AI research", numResults: 5 });
+     */
+    exa(path: string, body: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /**
+     * Neural web search via Exa. Returns semantically relevant URLs and metadata.
+     * Understands meaning, not just keywords. $0.01/call.
+     *
+     * @param query - Natural language search query
+     * @param options - Optional filters (numResults, category, date range, domains)
+     */
+    exaSearch(query: string, options?: ExaSearchOptions): Promise<ExaSearchResponse>;
+    /**
+     * Ask a question and get a cited, synthesized answer grounded in real web sources.
+     * No hallucinations — every claim is backed by a citation. $0.01/call.
+     *
+     * @param query - The question to answer
+     */
+    exaAnswer(query: string): Promise<ExaAnswerResponse>;
+    /**
+     * Fetch full Markdown text content from a list of URLs. $0.002 per URL.
+     * Returns clean text ready to feed into an LLM context window.
+     *
+     * @param urls - Array of URLs to fetch (up to 100)
+     */
+    exaContents(urls: string[]): Promise<ExaContentsResponse>;
+    /**
+     * Find pages semantically similar to a given URL. $0.01/call.
+     * Useful for discovering competitors, alternatives, and related resources.
+     *
+     * @param url - Reference URL
+     * @param options - Optional filters (numResults, excludeSourceDomain)
+     */
+    exaFindSimilar(url: string, options?: ExaFindSimilarOptions): Promise<ExaSearchResponse>;
+    /**
+     * Mint a one-time Coinbase Onramp link to fund this wallet with USDC on Base.
+     *
+     * FREE — the x402 signature only authenticates the wallet (no payment is
+     * charged). Because the funding address must equal the signing wallet, this
+     * mints a `pay.coinbase.com` link prefilled for `address` so a card/bank can
+     * top it up (60+ fiat currencies → Base USDC). Base / USDC only.
+     *
+     * The returned URL is single-use and expires in ~5 minutes — mint it at click
+     * time and never cache it. The funding `address` must match the signing wallet.
+     *
+     * @param address - Destination Base wallet address (0x + 40 hex chars). Must
+     *                  equal the signing wallet that funds it.
+     * @returns `{ url }` — a one-time https://pay.coinbase.com/... link.
+     *
+     * @example
+     * const { url } = await client.onramp(client.getWalletAddress());
+     * console.log(`Fund your wallet: ${url}`);
+     */
+    onramp(address: string): Promise<OnrampResult>;
+    /**
+     * Get USDC balance on Base mainnet.
+     *
+     * @returns USDC balance as a float (6 decimal places normalized)
+     *
+     * @example
+     * const balance = await client.getBalance();
+     * console.log(`Balance: $${balance.toFixed(2)} USDC`);
+     */
+    getBalance(): Promise<number>;
+    /**
+     * Query Predexon prediction market data (GET endpoints).
+     *
+     * Access real-time data from Polymarket, Kalshi, dFlow, and Binance Futures.
+     * Powered by Predexon. $0.001 per request.
+     *
+     * @param path - Endpoint path, e.g. "polymarket/events", "kalshi/markets/12345"
+     * @param params - Query parameters passed to the endpoint
+     *
+     * @example
+     * const events = await client.pm("polymarket/events");
+     * const market = await client.pm("kalshi/markets/KXBTC-25MAR14");
+     * const results = await client.pm("polymarket/search", { q: "bitcoin" });
+     */
+    pm(path: string, params?: Record<string, string>): Promise<Record<string, unknown>>;
+    /**
+     * Structured query for Predexon prediction market data (POST endpoints).
+     *
+     * For endpoints that require a JSON body, e.g. bulk wallet identity lookup.
+     * Tier 1 = $0.001/call, Tier 2 = $0.005/call.
+     *
+     * @param path - Endpoint path, e.g. "polymarket/wallet/identities"
+     * @param query - JSON body for the structured query
+     *
+     * @example
+     * const batch = await client.pmQuery("polymarket/wallet/identities", {
+     *   addresses: ["0xabc...", "0xdef..."],
+     * });
+     */
+    pmQuery(path: string, query: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** List canonical cross-venue markets (Predexon v2). Tier 1 ($0.001/call).
+     * Filter with venue, status, category, league, event_id, pagination_key. */
+    pmMarkets(params?: Record<string, string>): Promise<Record<string, unknown>>;
+    /** List venue-native executable listings flattened across canonical markets
+     * (Predexon v2). Tier 1 ($0.001/call). */
+    pmListings(params?: Record<string, string>): Promise<Record<string, unknown>>;
+    /** Resolve a canonical Predexon outcome ID to its market context and venue
+     * listings. Tier 1 ($0.001/call). */
+    pmOutcome(predexonId: string): Promise<Record<string, unknown>>;
+    /** Polymarket markets with cursor-based keyset pagination (use pagination_key).
+     * Tier 1 ($0.001/call). */
+    pmPolymarketMarketsKeyset(params?: Record<string, string>): Promise<Record<string, unknown>>;
+    /** Polymarket events with cursor-based keyset pagination (use pagination_key).
+     * Tier 1 ($0.001/call). */
+    pmPolymarketEventsKeyset(params?: Record<string, string>): Promise<Record<string, unknown>>;
+    /** List available sports categories. Tier 1 ($0.001/call). */
+    pmSportsCategories(): Promise<Record<string, unknown>>;
+    /** List sports markets grouped by game. Filter with league, sport_type,
+     * status, venue. Tier 1 ($0.001/call). */
+    pmSportsMarkets(params?: Record<string, string>): Promise<Record<string, unknown>>;
+    /** Fetch identity + profile metadata for one wallet (ENS, Twitter, portfolio,
+     * etc.). Tier 2 ($0.005/call). */
+    pmWalletIdentity(wallet: string): Promise<Record<string, unknown>>;
+    /** Bulk identity lookup for up to 200 wallet addresses (POST). Tier 2 ($0.005/call). */
+    pmWalletIdentities(addresses: string[]): Promise<Record<string, unknown>>;
+    /** Discover wallets connected to a seed address via on-chain transfers and
+     * identity proofs. Tier 2 ($0.005/call). */
+    pmWalletCluster(address: string): Promise<Record<string, unknown>>;
+    /**
+     * Query DefiLlama DeFi data (GET passthrough). Powered by DefiLlama.
+     * $0.005/call for protocols / protocol/{slug} / chains / yields;
+     * $0.001/call for prices/{coins}.
+     *
+     * @param path - e.g. "protocols", "protocol/aave", "chains", "yields",
+     *               "prices/coingecko:bitcoin,base:0x..."
+     * @param params - Query parameters passed through to DefiLlama
+     */
+    defi(path: string, params?: Record<string, string>): Promise<Record<string, unknown>>;
+    /** All DeFi protocols with TVL ($0.005/call). */
+    defiProtocols(): Promise<Record<string, unknown>>;
+    /** Single protocol details + historical TVL ($0.005/call). */
+    defiProtocol(slug: string): Promise<Record<string, unknown>>;
+    /** Current TVL of every chain ($0.005/call). */
+    defiChains(): Promise<Record<string, unknown>>;
+    /** Yield pools with APY/TVL ($0.005/call). */
+    defiYields(params?: Record<string, string>): Promise<Record<string, unknown>>;
+    /** Token price lookup ($0.001/call). Coins like "coingecko:bitcoin" or "{chain}:{address}". */
+    defiPrices(coins: string | string[]): Promise<Record<string, unknown>>;
+    /**
+     * Query the 0x Swap / Gasless APIs (free — no x402 payment; BlockRun
+     * takes an on-chain affiliate fee on executed swaps instead).
+     *
+     * @param path - "price", "quote", "gasless/price", "gasless/quote",
+     *               "gasless/submit" (POST), "gasless/status/{hash}",
+     *               "gasless/approval-tokens", "gasless/chains", "swap/chains"
+     * @param params - Query params (chainId, sellToken, buyToken, sellAmount, taker, ...)
+     * @param body - JSON body — pass to switch to POST (gasless/submit only)
+     */
+    dex(path: string, params?: Record<string, string>, body?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Indicative Permit2 swap price — no commitment (free). */
+    dexPrice(params: Record<string, string>): Promise<Record<string, unknown>>;
+    /** Firm Permit2 swap quote with permit2.eip712 + tx data (free). */
+    dexQuote(params: Record<string, string>): Promise<Record<string, unknown>>;
+    /** Gasless indicative price quote (free). */
+    dexGaslessPrice(params: Record<string, string>): Promise<Record<string, unknown>>;
+    /** Gasless firm quote — returns trade.eip712 to sign (free). */
+    dexGaslessQuote(params: Record<string, string>): Promise<Record<string, unknown>>;
+    /** Submit a signed gasless trade; the 0x relayer pays gas (free). */
+    dexGaslessSubmit(body: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Poll a gasless trade's status by tradeHash (free). */
+    dexGaslessStatus(tradeHash: string): Promise<Record<string, unknown>>;
+    /** Chains where the Swap API is supported (free). */
+    dexChains(): Promise<Record<string, unknown>>;
+    /** Chains where the Gasless API is supported (free). */
+    dexGaslessChains(): Promise<Record<string, unknown>>;
+    /**
+     * Call the Modal sandbox compute API (POST passthrough).
+     *
+     * @param path - "sandbox/create" ($0.01 CPU / $0.05 GPU), "sandbox/exec",
+     *               "sandbox/status", "sandbox/terminate" ($0.001 each)
+     * @param body - JSON body for the endpoint
+     */
+    modal(path: string, body?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Create a sandboxed compute environment ($0.01 CPU / $0.05 GPU). */
+    modalSandboxCreate(body?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Execute a command in a sandbox; returns stdout/stderr ($0.001). */
+    modalSandboxExec(sandboxId: string, command: string[], extra?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Check a sandbox's status ($0.001). */
+    modalSandboxStatus(sandboxId: string): Promise<Record<string, unknown>>;
+    /** Terminate a sandbox ($0.001). */
+    modalSandboxTerminate(sandboxId: string): Promise<Record<string, unknown>>;
+    /**
+     * Get current session spending.
+     *
+     * @returns Object with totalUsd and calls count
+     *
+     * @example
+     * const spending = client.getSpending();
+     * console.log(`Spent $${spending.totalUsd.toFixed(4)} across ${spending.calls} calls`);
+     */
+    getSpending(): Spending;
+    /**
+     * Get the wallet address being used for payments.
+     */
+    getWalletAddress(): string;
+}
+
+/**
+ * BlockRun Image Client - Generate images via x402 micropayments.
+ *
+ * SECURITY NOTE - Private Key Handling:
+ * Your private key NEVER leaves your machine. Here's what happens:
+ * 1. Key stays local - only used to sign an EIP-712 typed data message
+ * 2. Only the SIGNATURE is sent in the PAYMENT-SIGNATURE header
+ * 3. BlockRun verifies the signature on-chain via Coinbase CDP facilitator
+ *
+ * Usage:
+ *   import { ImageClient } from '@blockrun/llm';
+ *
+ *   const client = new ImageClient({ privateKey: '0x...' });
+ *   const result = await client.generate('A cute cat in space');
+ *   console.log(result.data[0].url);
+ */
+
+/**
+ * BlockRun Image Generation Client.
+ *
+ * Generate images using Nano Banana (Google Gemini), DALL-E 3, GPT Image,
+ * or CogView-4 (Zhipu AI) with automatic x402 micropayments on Base chain.
+ */
+declare class ImageClient {
+    private account;
+    private privateKey;
+    private apiUrl;
+    private timeout;
+    private sessionTotalUsd;
+    private sessionCalls;
+    /**
+     * Initialize the BlockRun Image client.
+     *
+     * @param options - Client configuration options
+     */
+    constructor(options?: ImageClientOptions);
+    /**
+     * Generate an image from a text prompt.
+     *
+     * @param prompt - Text description of the image to generate
+     * @param options - Optional generation parameters
+     * @returns ImageResponse with generated image URLs
+     *
+     * @example
+     * const result = await client.generate('A sunset over mountains');
+     * console.log(result.data[0].url);
+     */
+    generate(prompt: string, options?: ImageGenerateOptions): Promise<ImageResponse>;
+    /**
+     * Edit an image using img2img, optionally fusing multiple source images.
+     *
+     * Pass a single `data:image/...` base64 data URI to edit one image, or an
+     * array of 2–4 data URIs to fuse them (image fusion) — e.g. a reference photo
+     * plus a brand logo. The server caps fusion per provider: `openai/*` accepts
+     * up to 4 source images, `google/*` (Nano Banana) up to 3. A `mask` cannot be
+     * combined with multiple source images.
+     *
+     * Edit-capable models: `openai/gpt-image-1`, `openai/gpt-image-2`,
+     * `google/nano-banana`, `google/nano-banana-pro`.
+     *
+     * @param prompt - Text description of the desired edit
+     * @param image - A base64 `data:image/...` URI, or an array of 2–4 such URIs to fuse
+     * @param options - Optional edit parameters
+     * @returns ImageResponse with edited image URLs
+     *
+     * @example
+     * // Single-image edit
+     * const result = await client.edit('Make it a painting', imageDataUri);
+     *
+     * @example
+     * // Multi-image fusion (Nano Banana): blend a subject with a brand logo
+     * const fused = await client.edit(
+     *   'Place the logo on the t-shirt',
+     *   [subjectDataUri, logoDataUri],
+     *   { model: 'google/nano-banana' }
+     * );
+     */
+    edit(prompt: string, image: string | string[], options?: ImageEditOptions): Promise<ImageResponse>;
+    /**
+     * List available image generation models with pricing.
+     *
+     * The dedicated `/v1/images/models` endpoint was deprecated server-side;
+     * image models live in the unified `/v1/models` catalog under
+     * `categories: ["image", ...]`. This method filters that catalog so
+     * existing callers keep working.
+     */
+    listImageModels(): Promise<ImageModel[]>;
+    /**
+     * Make a request with automatic x402 payment handling.
+     */
+    private requestWithPayment;
+    /**
+     * Handle 402 response: parse requirements, sign payment, retry.
+     */
+    private handlePaymentAndRetry;
+    /**
+     * Poll the async image generation endpoint until the job reaches a terminal
+     * state (completed/failed). Used when the POST returns 202 + poll_url for
+     * slow models that exceeded the server's inline window.
+     *
+     * Sends the SAME payment header on every poll — the server binds the payer
+     * to the job id and re-verifies on each call. Settlement happens server-side
+     * on the first poll where status=completed.
+     */
+    private pollImageJob;
+    /**
+     * Fetch with timeout.
+     */
+    private fetchWithTimeout;
+    /**
+     * Get the wallet address being used for payments.
+     */
+    getWalletAddress(): string;
+    /**
+     * Get session spending information.
+     */
+    getSpending(): Spending;
+}
+
+/**
+ * BlockRun Music Client - Generate music tracks via x402 micropayments.
+ *
+ * SECURITY NOTE - Private Key Handling:
+ * Your private key NEVER leaves your machine. Here's what happens:
+ * 1. Key stays local - only used to sign an EIP-712 typed data message
+ * 2. Only the SIGNATURE is sent in the PAYMENT-SIGNATURE header
+ * 3. BlockRun verifies the signature on-chain via Coinbase CDP facilitator
+ *
+ * Usage:
+ *   import { MusicClient } from '@blockrun/llm';
+ *
+ *   const client = new MusicClient({ privateKey: '0x...' });
+ *   const result = await client.generate('upbeat synthwave with neon pads');
+ *   console.log(result.data[0].url); // CDN URL — download within 24h
+ */
+
+/**
+ * BlockRun Music Generation Client.
+ *
+ * Generate full-length ~3 minute music tracks using MiniMax Music 2.5+
+ * with automatic x402 micropayments on Base chain.
+ *
+ * Pricing: $0.1575/track
+ * Note: Generated URLs expire in ~24h — download immediately if needed.
+ */
+declare class MusicClient {
+    private account;
+    private privateKey;
+    private apiUrl;
+    private timeout;
+    private sessionTotalUsd;
+    private sessionCalls;
+    constructor(options?: MusicClientOptions);
+    /**
+     * Generate a music track from a text prompt.
+     *
+     * Takes 1-3 minutes. Returns a CDN URL valid for ~24h.
+     *
+     * @param prompt - Music style, mood, or description
+     * @param options - Optional generation parameters
+     * @returns MusicResponse with track URL and metadata
+     *
+     * @example
+     * const result = await client.generate('chill lo-fi beats with piano');
+     * console.log(result.data[0].url); // Download this URL — expires in 24h
+     *
+     * @example With lyrics
+     * const result = await client.generate('upbeat pop song', {
+     *   instrumental: false,
+     *   lyrics: 'Hello world, this is my song...'
+     * });
+     */
+    generate(prompt: string, options?: MusicGenerateOptions): Promise<MusicResponse>;
+    private requestWithPayment;
+    private handlePaymentAndRetry;
+    private fetchWithTimeout;
+    getWalletAddress(): string;
+    getSpending(): Spending;
+}
+
+/**
+ * BlockRun Speech Client - Text-to-speech and sound effects (ElevenLabs) via x402 micropayments.
+ *
+ * SECURITY NOTE - Private Key Handling:
+ * Your private key NEVER leaves your machine. Here's what happens:
+ * 1. Key stays local - only used to sign an EIP-712 typed data message
+ * 2. Only the SIGNATURE is sent in the PAYMENT-SIGNATURE header
+ * 3. BlockRun verifies the signature on-chain via Coinbase CDP facilitator
+ *
+ * Usage:
+ *   import { SpeechClient } from '@blockrun/llm';
+ *
+ *   const client = new SpeechClient({ privateKey: '0x...' });
+ *
+ *   // Text-to-speech (price scales with character count)
+ *   const result = await client.generate('Hello from BlockRun!', { voice: 'sarah' });
+ *   console.log(result.data[0].url);
+ *
+ *   // Sound effects (flat $0.05/generation)
+ *   const fx = await client.soundEffect('rain on a tin roof, distant thunder');
+ *
+ *   // List voices (free, rate-limited)
+ *   const voices = await client.listVoices();
+ *
+ * Models & pricing:
+ *   elevenlabs/flash-v2.5        $0.05/1k chars  ~75ms latency, 32 languages (default)
+ *   elevenlabs/turbo-v2.5        $0.05/1k chars  ~250ms latency, 32 languages
+ *   elevenlabs/multilingual-v2   $0.10/1k chars  long-form narration, 29 languages
+ *   elevenlabs/v3                $0.10/1k chars  max expressiveness, 70+ languages
+ *   elevenlabs/sound-effects     $0.05/generation (up to 22s)
+ *
+ * Price = (characters / 1000) x model rate, minimum $0.001/request.
+ */
+
+/**
+ * BlockRun Speech Client (BlockRun Voice).
+ *
+ * Text-to-speech and sound-effect generation using ElevenLabs models
+ * with automatic x402 micropayments on Base chain.
+ *
+ * TTS pricing scales with input characters; sound effects are flat
+ * $0.05/generation.
+ */
+declare class SpeechClient {
+    private account;
+    private privateKey;
+    private apiUrl;
+    private timeout;
+    private sessionTotalUsd;
+    private sessionCalls;
+    constructor(options?: SpeechClientOptions);
+    /**
+     * Synthesize speech from text (OpenAI-compatible TTS).
+     *
+     * Price scales with character count: (chars / 1000) x model rate,
+     * minimum $0.001/request. Synthesis is synchronous.
+     *
+     * @param input - Text to synthesize. Per-model character caps apply
+     *                (flash/turbo 40k, multilingual-v2 10k, v3 5k).
+     * @param options - Optional model / voice / format / speed
+     * @returns SpeechResponse with audio URL, format, and character count
+     *
+     * @example
+     * const result = await client.generate('Welcome to BlockRun.', { voice: 'george' });
+     * console.log(result.data[0].url); // audio URL (mp3 by default)
+     */
+    generate(input: string, options?: SpeechGenerateOptions): Promise<SpeechResponse>;
+    /** OpenAI-style alias for {@link generate}. */
+    speak(input: string, options?: SpeechGenerateOptions): Promise<SpeechResponse>;
+    /**
+     * Generate a cinematic sound effect from a text prompt.
+     *
+     * Flat $0.05/generation, up to 22 seconds of audio.
+     *
+     * @param text - Sound effect description (max 1000 chars).
+     *               E.g. 'rain on a tin roof', 'sci-fi door whoosh'
+     * @param options - Optional duration / prompt influence / format
+     * @returns SpeechResponse with audio URL and format
+     *
+     * @example
+     * const fx = await client.soundEffect('crackling campfire at night');
+     * console.log(fx.data[0].url);
+     */
+    soundEffect(text: string, options?: SoundEffectOptions): Promise<SpeechResponse>;
+    /**
+     * List available voices for TTS (free, rate-limited 60 req/min/IP).
+     *
+     * Pass a voice's `alias` (if present) or `voice_id` as the `voice`
+     * option to {@link generate}.
+     */
+    listVoices(): Promise<VoiceInfo[]>;
+    private requestWithPayment;
+    private handlePaymentAndRetry;
+    private fetchWithTimeout;
+    getWalletAddress(): string;
+    getSpending(): Spending;
+}
+
+/**
+ * BlockRun Video Client - Generate short AI videos via x402 micropayments.
+ *
+ * SECURITY NOTE - Private Key Handling:
+ * Your private key NEVER leaves your machine. Here's what happens:
+ * 1. Key stays local - only used to sign an EIP-712 typed data message
+ * 2. Only the SIGNATURE is sent in the PAYMENT-SIGNATURE header
+ * 3. BlockRun verifies the signature on-chain via Coinbase CDP facilitator
+ *
+ * Async flow (client-polled):
+ *   POST /v1/videos/generations         -> 402 -> sign -> 202 { id, poll_url }
+ *   GET  /v1/videos/generations/{id}    -> loop until status=completed
+ *
+ * The client signs once and replays the same PAYMENT-SIGNATURE on every poll,
+ * re-signing automatically if the 600s authorization window lapses mid-poll.
+ * Settlement happens only on the first completed poll, so upstream failure or
+ * the caller giving up = zero charge.
+ *
+ * Usage:
+ *   import { VideoClient } from '@blockrun/llm';
+ *
+ *   const client = new VideoClient({ privateKey: '0x...' });
+ *   const result = await client.generate('a red apple slowly spinning on a wooden table');
+ *   console.log(result.data[0].url);            // permanent MP4 URL
+ *   console.log(result.data[0].duration_seconds);
+ */
+
+/**
+ * BlockRun Video Generation Client.
+ *
+ * Supports xAI Grok Imagine Video and ByteDance Seedance (1.5 Pro /
+ * 2.0 Fast / 2.0 Pro) with automatic x402 micropayments on Base.
+ */
+declare class VideoClient {
+    private account;
+    private privateKey;
+    private apiUrl;
+    private timeout;
+    private sessionTotalUsd;
+    private sessionCalls;
+    constructor(options?: VideoClientOptions);
+    /**
+     * Generate a short video clip from a text prompt (or text + image).
+     *
+     * Submits an async job, then polls until the video is ready. Typical total
+     * wall-time is 60-180s, but upstream status can lag several minutes behind
+     * actual completion. If upstream runs past the budget (default 15min),
+     * throws without charging — the job stays claimable ~48h via poll_url.
+     *
+     * @param prompt - Text description of the video
+     * @param options - Optional generation parameters
+     */
+    generate(prompt: string, options?: VideoGenerateOptions & {
+        budgetMs?: number;
+    }): Promise<VideoResponse>;
+    /**
+     * Generate a video from a standard Seedance `content[]` body.
+     *
+     * Targets the gateway's `POST /v1/videos` endpoint, which accepts the
+     * mainstream multimodal `content` array (text + a single reference image)
+     * used by other Seedance APIs — so callers already holding a
+     * `content[]`-shaped request can submit it unchanged. The gateway validates
+     * unsupported inputs *before* charging, then delegates to the same x402
+     * submit+poll pipeline as {@link generate}.
+     *
+     * Most SDK users should prefer {@link generate} (structured options like
+     * `imageUrl` / `lastFrameUrl`) — this exists for migrating existing
+     * `content[]` payloads with no reshaping.
+     *
+     * @param content - The Seedance `content` array, e.g.
+     *   `[{ type: "text", text: "a red apple spinning" }]` or a text item plus
+     *   `{ type: "image_url", image_url: { url: "https://..." } }`.
+     * @param options - `model`, `budgetMs`, plus the same camelCase render options
+     *   as {@link generate} (`durationSeconds`, `aspectRatio`, `resolution`,
+     *   `generateAudio`, `seed`, `watermark`, `returnLastFrame`). These are mapped
+     *   to the gateway's snake_case fields for you. Any other keys you pass are
+     *   forwarded verbatim (use snake_case for those, since the gateway reads
+     *   snake_case only).
+     */
+    generateFromContent(content: Array<Record<string, unknown>>, options?: {
+        model?: string;
+        budgetMs?: number;
+        durationSeconds?: number;
+        aspectRatio?: string;
+        resolution?: string;
+        generateAudio?: boolean;
+        seed?: number;
+        watermark?: boolean;
+        returnLastFrame?: boolean;
+    } & Record<string, unknown>): Promise<VideoResponse>;
+    private submitAndPoll;
+    /**
+     * Parse an x402 challenge response and sign a payment payload for it.
+     * Used for the initial submit AND for mid-poll re-signing after the 600s
+     * authorization window lapses on long polls.
+     */
+    private signFromChallenge;
+    private absolute;
+    private extractPaymentRequired;
+    private throwApiError;
+    private fetchWithTimeout;
+    getWalletAddress(): string;
+    getSpending(): Spending;
+}
+
+/**
+ * BlockRun Voice Call Client - AI-powered outbound phone calls via x402 micropayments.
+ *
+ * The AI agent calls a phone number (E.164) and conducts a real-time conversation
+ * based on your 'task' instructions. STT, LLM, and TTS are handled upstream by
+ * Bland.ai; BlockRun handles billing through x402.
+ *
+ * SECURITY NOTE - Private Key Handling:
+ * Your private key NEVER leaves your machine. Here's what happens:
+ * 1. Key stays local - only used to sign an EIP-712 typed data message
+ * 2. Only the SIGNATURE is sent in the PAYMENT-SIGNATURE header
+ * 3. BlockRun verifies the signature on-chain via Coinbase CDP facilitator
+ *
+ * Usage:
+ *   import { VoiceClient } from '@blockrun/llm';
+ *
+ *   const client = new VoiceClient({ privateKey: '0x...' });
+ *
+ *   // Initiate a call (paid, $0.54)
+ *   const result = await client.call({
+ *     to: '+14155552671',
+ *     task: 'You are a friendly assistant calling to confirm a 3pm dentist appointment.',
+ *     max_duration: 5,
+ *   });
+ *   console.log(result.call_id);
+ *
+ *   // Poll status, transcript, recording (free)
+ *   const status = await client.getStatus(result.call_id);
+ *   console.log(status);
+ */
+
+/**
+ * BlockRun Voice Call Client.
+ *
+ * Initiates AI-powered outbound phone calls with automatic x402 micropayments
+ * on Base chain.
+ *
+ * Pricing: $0.54 per call (regardless of duration up to max_duration).
+ * Status polling is free.
+ */
+declare class VoiceClient {
+    private account;
+    private privateKey;
+    private apiUrl;
+    private timeout;
+    private sessionTotalUsd;
+    private sessionCalls;
+    constructor(options?: VoiceClientOptions);
+    /**
+     * Initiate an AI-powered outbound phone call.
+     *
+     * Pricing: $0.54 per call. Returns immediately once the call is queued —
+     * poll getStatus() for transcript and recording.
+     *
+     * @example
+     *   const r = await client.call({
+     *     to: '+14155552671',
+     *     task: 'Confirm the user wants to reschedule to Tuesday 2pm.',
+     *     voice: 'maya',
+     *     max_duration: 3,
+     *   });
+     */
+    call(options: CallOptions): Promise<CallInitiatedResponse>;
+    /**
+     * Poll the status of an in-progress or completed call. Free — no payment.
+     *
+     * Returns Bland.ai's full call record: status, transcript, recording URL, etc.
+     * Most fields populate only once the call ends.
+     */
+    getStatus(callId: string): Promise<CallStatusResponse>;
+    private requestWithPayment;
+    private handlePaymentAndRetry;
+    private fetchWithTimeout;
+    getWalletAddress(): string;
+    getSpending(): Spending;
+}
+
+/**
+ * BlockRun Phone Client — Twilio-backed phone lookup + number provisioning via x402.
+ *
+ * Endpoints (all under /v1/phone/...):
+ *   POST /lookup            $0.01    Carrier + line-type lookup
+ *   POST /lookup/fraud      $0.05    Carrier + SIM-swap / call-forwarding signals
+ *   POST /numbers/buy       $5.00    Provision a US/CA number (30-day lease, bound to wallet)
+ *   POST /numbers/renew     $5.00    Extend an existing number by 30 days
+ *   POST /numbers/list      $0.001   List the wallet's active numbers
+ *   POST /numbers/release   free     Release a provisioned number (still flows through x402
+ *                                    so the backend can verify wallet identity)
+ *
+ * After buying a number you can use it as the `from` caller ID in VoiceClient.call().
+ *
+ * SECURITY NOTE — your private key never leaves your machine. Only EIP-712
+ * signatures are sent in the PAYMENT-SIGNATURE header.
+ *
+ * @example
+ *   import { PhoneClient } from '@blockrun/llm';
+ *
+ *   const client = new PhoneClient({ privateKey: '0x...' });
+ *
+ *   // Lookup a number
+ *   const info = await client.lookup('+14155552671');
+ *
+ *   // Buy a number (US, optional area code)
+ *   const bought = await client.buyNumber({ country: 'US', areaCode: '415' });
+ *   console.log(bought.phone_number, bought.expires_at);
+ *
+ *   // List your active numbers
+ *   console.log(await client.listNumbers());
+ *
+ *   // Renew / release
+ *   await client.renewNumber(bought.phone_number);
+ *   await client.releaseNumber(bought.phone_number);
+ */
+
+/** Per-endpoint price in USD — mirrors the backend's `PHONE_PRICES`. */
+declare const PHONE_PRICES: Readonly<Record<string, number>>;
+/**
+ * BlockRun Phone Client.
+ *
+ * Wraps the `/v1/phone/*` x402 endpoints — phone-number lookup (carrier + fraud)
+ * and provisioning of the caller-ID numbers required by VoiceClient.call().
+ */
+declare class PhoneClient {
+    private account;
+    private privateKey;
+    private apiUrl;
+    private timeout;
+    private sessionTotalUsd;
+    private sessionCalls;
+    constructor(options?: PhoneClientOptions);
+    /** EVM wallet address used for payments. */
+    getWalletAddress(): string;
+    /** Session-cumulative USD spend + call count across this client instance. */
+    getSpending(): Spending;
+    /**
+     * Carrier + line-type lookup. ~$0.01.
+     *
+     * @param phoneNumber E.164 number (e.g. "+14155552671").
+     */
+    lookup(phoneNumber: string): Promise<PhoneLookupResponse>;
+    /**
+     * Lookup + fraud signals (SIM swap, call forwarding). ~$0.05.
+     *
+     * @param phoneNumber E.164 number.
+     */
+    lookupFraud(phoneNumber: string): Promise<PhoneLookupResponse>;
+    /**
+     * Provision a dedicated phone number for 30 days. $5.00.
+     *
+     * Payment is settled only after Twilio confirms the purchase, so failed
+     * buys never charge your wallet.
+     *
+     * @param options.country  ISO country code, "US" or "CA" (default "US").
+     * @param options.areaCode Optional 3-digit area-code hint. Availability is
+     *   not guaranteed — the backend falls back to any number in the country if
+     *   the area code can't be matched.
+     */
+    buyNumber(options?: PhoneBuyOptions): Promise<PhoneBuyResponse>;
+    /**
+     * Extend an existing provisioned number by 30 days. $5.00.
+     *
+     * @throws {APIError} 403 when the wallet doesn't own the number or it has expired.
+     */
+    renewNumber(phoneNumber: string): Promise<PhoneRenewResponse>;
+    /** List the wallet's active phone numbers. ~$0.001. */
+    listNumbers(): Promise<PhoneListResponse>;
+    /**
+     * Release a provisioned number back to the Twilio pool. Free, but still
+     * flows through x402 so the backend can verify ownership.
+     */
+    releaseNumber(phoneNumber: string): Promise<PhoneReleaseResponse>;
+    private request;
+    private handlePaymentAndRetry;
+    private unwrap;
+    private fetchWithTimeout;
+}
+
+/**
+ * BlockRun Portrait Client — enroll a Virtual Portrait via x402.
+ *
+ * Wraps `POST /v1/portrait/enroll` ($0.01 USDC promo, no KYC). You upload a face image
+ * by URL and get back a Token360 asset id (`ta_xxxxxx`). Pass that id as
+ * `realFaceAssetId` on a Seedance 2.0 video generation (VideoClient.generate)
+ * to keep the same AI character across clips.
+ *
+ * SECURITY NOTE — your private key never leaves your machine. Only EIP-712
+ * signatures are sent in the PAYMENT-SIGNATURE header.
+ *
+ * @example
+ *   import { PortraitClient, VideoClient } from '@blockrun/llm';
+ *
+ *   const portraits = new PortraitClient({ privateKey: '0x...' });
+ *   const { asset_id } = await portraits.enroll({
+ *     name: 'Spokesperson',
+ *     imageUrl: 'https://example.com/face.jpg',
+ *   });
+ *
+ *   const video = new VideoClient({ privateKey: '0x...' });
+ *   const clip = await video.generate('she waves and smiles', {
+ *     model: 'bytedance/seedance-2.0-fast',
+ *     realFaceAssetId: asset_id,
+ *   });
+ */
+
+/**
+ * Flat enrollment price in USD — mirrors the backend's `ENROLLMENT_PRICE_USD`.
+ * Currently $0.01 (promotional, parity with RealFace). The authoritative price
+ * is whatever the gateway quotes in the 402; this constant is informational.
+ */
+declare const PORTRAIT_ENROLLMENT_PRICE_USD = 0.01;
+/**
+ * BlockRun Portrait Client.
+ *
+ * Enrolls a Virtual Portrait from a face image URL and returns the `ta_xxxxxx`
+ * asset id consumed by Seedance 2.0 video generation. Real-person likeness is
+ * not supported on BlockRun — enrolled portraits are AI characters.
+ */
+declare class PortraitClient {
+    private account;
+    private privateKey;
+    private apiUrl;
+    private timeout;
+    private sessionTotalUsd;
+    private sessionCalls;
+    constructor(options?: PortraitClientOptions);
+    /** EVM wallet address used for payments. */
+    getWalletAddress(): string;
+    /** Session-cumulative USD spend + call count across this client instance. */
+    getSpending(): Spending;
+    /**
+     * Enroll a Virtual Portrait from a face image URL. $0.01 (promo).
+     *
+     * Payment is settled only after Token360 confirms the enrollment, so failed
+     * enrollments never charge your wallet.
+     *
+     * @param options.name     Display name (1–64 chars).
+     * @param options.imageUrl Public HTTPS URL to a JPG/PNG/WEBP image (≤10 MB).
+     * @returns The enrollment record, including `asset_id` (`ta_xxxxxx`).
+     */
+    enroll(options: PortraitEnrollOptions): Promise<PortraitEnrollResponse>;
+    private request;
+    private handlePaymentAndRetry;
+    private unwrap;
+    private fetchWithTimeout;
+}
+
+/**
+ * BlockRun Search Client - Standalone Grok Live Search via x402 micropayments.
+ *
+ * Backend endpoint: POST /api/v1/search
+ * Pricing: $0.025/source + margin (default 10 sources ≈ $0.26).
+ *
+ * Usage:
+ *   import { SearchClient } from "@bridgenode/llm";
+ *
+ *   const client = new SearchClient({ privateKey: "0x..." });
+ *   const result = await client.search("Latest news on x402 adoption", {
+ *     sources: ["x", "web"],
+ *   });
+ *   console.log(result.summary);
+ */
+
+declare class SearchClient {
+    private account;
+    private privateKey;
+    private apiUrl;
+    private timeout;
+    constructor(options?: SearchClientOptions);
+    search(query: string, options?: SearchOptions): Promise<SearchResult>;
+    private requestWithPayment;
+    private handlePaymentAndRetry;
+    private fetchWithTimeout;
+    getWalletAddress(): string;
+}
+
+/**
+ * BlockRun Price Client - Pyth-backed market data via x402.
+ *
+ * Payment gating mirrors CategoryConfig.paid in the backend:
+ *   crypto, fx, commodity      → FREE across price + history + list
+ *   usstock, stocks/{market}   → PAID for price + history; list always free
+ *
+ * Usage:
+ *   import { PriceClient } from "@bridgenode/llm";
+ *
+ *   const p = new PriceClient({ privateKey: "0x..." });
+ *   const btc = await p.price("crypto", "BTC-USD");
+ *   const aapl = await p.price("stocks", "AAPL", { market: "us" });
+ *   const bars = await p.history("stocks", "AAPL", { market: "us",
+ *     from: 1700000000, to: 1710000000 });
+ *   const symbols = await p.listSymbols("crypto", { query: "sol" });
+ */
+
+declare class PriceClient {
+    private account;
+    private privateKey;
+    private apiUrl;
+    private timeout;
+    constructor(options?: PriceClientOptions);
+    price(category: PriceCategory, symbol: string, options?: PriceOptions): Promise<PricePoint>;
+    history(category: PriceCategory, symbol: string, options: HistoryOptions): Promise<PriceHistoryResponse>;
+    listSymbols(category: PriceCategory, options?: ListOptions): Promise<SymbolListResponse>;
+    getWalletAddress(): string | null;
+    private getWithPayment;
+    private payAndRetry;
+    private fetchWithTimeout;
+}
+
+/**
+ * BlockRun Surf Client — pay-per-call crypto data via x402 micropayments.
+ *
+ * Surf aggregates 84+ endpoints across CEX/DEX market data, on-chain SQL,
+ * wallet intelligence, prediction markets, social analytics, and news under
+ * a single OpenAPI surface mounted at `/api/v1/surf/*`.
+ *
+ * Pricing tiers (flat per-call, USDC on Base):
+ *   Tier 1 — $0.001/call (prices, rankings, lists, news, simple reads)
+ *   Tier 2 — $0.005/call (order books, candles, search, wallet details)
+ *   Tier 3 — $0.020/call (on-chain SQL, schema introspection, chat)
+ *
+ * Because the catalog is large and evolving, this client deliberately
+ * exposes a thin `get` / `post` pair instead of 84 typed wrappers. Pass the
+ * path (with or without the `/v1/surf` prefix) and either query params or a
+ * JSON body. The full endpoint inventory lives at
+ * https://bridgenode.cc/marketplace/surf.
+ *
+ * Usage:
+ *   import { SurfClient } from "@bridgenode/llm";
+ *
+ *   const surf = new SurfClient({ privateKey: "0x..." });
+ *
+ *   // Tier 1 — token price ($0.001)
+ *   const btc = await surf.get("/market/price", { symbol: "BTC" });
+ *
+ *   // Tier 2 — order book ($0.005)
+ *   const book = await surf.get("/exchange/depth", {
+ *     exchange: "binance",
+ *     symbol: "BTC-USDT",
+ *   });
+ *
+ *   // Tier 3 — raw on-chain SQL ($0.020)
+ *   const rows = await surf.post("/onchain/sql", {
+ *     query: "SELECT block_number FROM ethereum.blocks ORDER BY block_number DESC LIMIT 5",
+ *   });
+ *
+ *   // Typed responses via generic
+ *   type Price = { symbol: string; price: number; timestamp: string };
+ *   const typed = await surf.get<Price>("/market/price", { symbol: "ETH" });
+ */
+
+type QueryValue$1 = string | number | boolean | null | undefined;
+type QueryParams$1 = Record<string, QueryValue$1 | QueryValue$1[]>;
+declare class SurfClient {
+    private account;
+    private privateKey;
+    private apiUrl;
+    private timeout;
+    constructor(options?: SurfClientOptions);
+    /**
+     * GET a Surf endpoint. `path` is everything after `/v1/surf` (a leading
+     * `/v1/surf` is tolerated and stripped). Query params are URL-encoded;
+     * arrays become repeated keys (`?a=1&a=2`).
+     */
+    get<T = unknown>(path: string, params?: QueryParams$1): Promise<T>;
+    /**
+     * POST a Surf endpoint with a JSON body. Same path normalization as `get`.
+     */
+    post<T = unknown>(path: string, body?: Record<string, unknown>): Promise<T>;
+    private buildUrl;
+    private requestWithPayment;
+    private handlePaymentAndRetry;
+    private throwApiError;
+    private fetchWithTimeout;
+    getWalletAddress(): string;
+}
+
+/**
+ * BlockRun RPC Client - Multi-chain JSON-RPC (Tatum gateway) via x402 micropayments.
+ *
+ * One endpoint, 40+ chains: Ethereum, Base, Solana, Polygon, BSC, Arbitrum,
+ * Optimism, Avalanche, Bitcoin, Sui, and more. Standard JSON-RPC 2.0
+ * passthrough — no API key, pay-per-call in USDC.
+ *
+ * SECURITY NOTE - Private Key Handling:
+ * Your private key NEVER leaves your machine. Here's what happens:
+ * 1. Key stays local - only used to sign an EIP-712 typed data message
+ * 2. Only the SIGNATURE is sent in the PAYMENT-SIGNATURE header
+ * 3. BlockRun verifies the signature on-chain via Coinbase CDP facilitator
+ *
+ * Usage:
+ *   import { RpcClient } from '@blockrun/llm';
+ *
+ *   const client = new RpcClient({ privateKey: '0x...' });
+ *
+ *   // EVM chains speak eth_* JSON-RPC
+ *   const block = await client.call('ethereum', 'eth_blockNumber');
+ *   console.log(block.result); // e.g. "0x1499f7c"
+ *
+ *   const balance = await client.call('base', 'eth_getBalance', [
+ *     '0x4200000000000000000000000000000000000006',
+ *     'latest',
+ *   ]);
+ *
+ *   // Non-EVM chains speak their native JSON-RPC
+ *   const slot = await client.call('solana', 'getSlot');
+ *
+ *   // Batch: one payment, per-element pricing ($0.002 x N)
+ *   const out = await client.batch('polygon', [
+ *     { method: 'eth_blockNumber' },
+ *     { method: 'eth_gasPrice' },
+ *   ]);
+ *
+ * Pricing:
+ *   Flat $0.002 per JSON-RPC call; a batch charges per element.
+ *
+ * Networks:
+ *   40 curated chains (see SUPPORTED_NETWORKS) plus common aliases
+ *   (eth, arb, op, matic, bnb, avax, sol, btc, xrp, dot, ...). Unknown but
+ *   well-formed slugs fall through to a generic `{slug}-mainnet` gateway
+ *   attempt, so new Tatum chains work without an SDK update.
+ */
+
+/**
+ * Flat price per JSON-RPC call (batch = N x this). Informational only —
+ * the actual quote always comes from the 402 challenge.
+ */
+declare const RPC_PRICE_USD = 0.002;
+/**
+ * Curated chains accepted by /v1/rpc/{network}. Mirrors the backend chain
+ * registry (verified live 2026-06-07). EVM chains use eth_* JSON-RPC;
+ * non-EVM (Solana / UTXO / NEAR / Sui / XRP Ledger / Polkadot) speak their
+ * own JSON-RPC dialect.
+ */
+declare const SUPPORTED_NETWORKS: readonly ["ethereum", "base", "arbitrum", "arbitrum-nova", "optimism", "polygon", "bsc", "avalanche", "fantom", "cronos", "celo", "gnosis", "zksync", "berachain", "unichain", "monad", "chiliz", "moonbeam", "aurora", "flare", "oasis", "kaia", "sonic", "xdc", "abstract", "hyperevm", "plume", "ronin", "rootstock", "solana", "bitcoin", "litecoin", "dogecoin", "bitcoin-cash", "near", "sui", "ripple", "polkadot", "kusama", "zcash"];
+type RpcNetwork = (typeof SUPPORTED_NETWORKS)[number] | (string & {});
+/** Common short names the gateway also accepts (resolved server-side). */
+declare const NETWORK_ALIASES: Record<string, string>;
+/**
+ * BlockRun Multi-chain RPC Client.
+ *
+ * Standard JSON-RPC 2.0 access to 40+ chains through BlockRun's Tatum
+ * gateway with automatic x402 micropayments on Base chain.
+ *
+ * Flat $0.002 per call; a JSON-RPC batch charges per element.
+ */
+declare class RpcClient {
+    private account;
+    private privateKey;
+    private apiUrl;
+    private timeout;
+    private sessionTotalUsd;
+    private sessionCalls;
+    constructor(options?: RpcClientOptions);
+    /**
+     * Make a single JSON-RPC 2.0 call. Flat $0.002.
+     *
+     * @param network - Chain name (e.g. "ethereum", "base", "solana") or a
+     *                  common alias ("eth", "sol", "matic", ...). See
+     *                  SUPPORTED_NETWORKS / NETWORK_ALIASES.
+     * @param method - Chain RPC method, e.g. "eth_blockNumber", "eth_call",
+     *                 "eth_getBalance" (EVM) or "getSlot", "getAccountInfo"
+     *                 (Solana).
+     * @param params - Method-specific params array (optional).
+     * @returns RpcResponse with `result` (or JSON-RPC `error`), plus
+     *          `network`, `cacheHit` and `txHash` metadata.
+     *
+     * @example
+     * const block = await client.call('ethereum', 'eth_blockNumber');
+     * console.log(parseInt(block.result as string, 16));
+     */
+    call<T = unknown>(network: RpcNetwork, method: string, params?: unknown[]): Promise<RpcResponse<T>>;
+    /**
+     * Make a JSON-RPC 2.0 batch call. Priced per element ($0.002 x N).
+     *
+     * @param network - Chain name or alias (see {@link call}).
+     * @param requests - Requests, each with a `method` and optional
+     *                   `params` / `id`. `jsonrpc` and missing ids are
+     *                   filled in automatically.
+     * @returns Array of RpcResponse, in upstream order.
+     *
+     * @example
+     * const out = await client.batch('base', [
+     *   { method: 'eth_blockNumber' },
+     *   { method: 'eth_gasPrice' },
+     * ]);
+     */
+    batch(network: RpcNetwork, requests: RpcBatchRequest[]): Promise<RpcResponse[]>;
+    private toResponse;
+    private requestWithPayment;
+    private handlePaymentAndRetry;
+    private fetchWithTimeout;
+    getWalletAddress(): string;
+    getSpending(): Spending;
+}
+
+/**
+ * BlockrunClient — the x402-paying HTTP primitive for the BridgeNode gateway.
+ *
+ * This is the **primitive** that every BlockRun API surface composes on top of:
+ * a wallet, an x402 401-sign-replay handler, and four call shapes (get, post,
+ * poll, stream). Per-API classes (LLMClient, ImageClient, SurfClient, …) are
+ * being collapsed into Claude Code skills that drive this client directly.
+ *
+ * Why one primitive instead of one client per API surface:
+ *   - Every BlockRun endpoint pays the same way (USDC via x402 on Base/Solana)
+ *   - ~30-40 % of each existing client class is identical boilerplate
+ *   - New API surfaces should ship as a skill (markdown) + path, not as a
+ *     new TypeScript class + npm release
+ *
+ * Four call shapes:
+ *   client.get<T>(path, params?)                — sync GET, e.g. /v1/surf/market/price
+ *   client.post<T>(path, body?)                 — sync POST, e.g. /v1/surf/onchain/sql
+ *   client.poll<T>(path, body?, { budgetMs })   — submit + poll, e.g. /v1/videos/generations
+ *   client.stream<T>(path, body?)               — SSE iterator, e.g. /v1/chat/completions
+ *
+ * Usage:
+ *   import { BlockrunClient } from "@bridgenode/llm";
+ *
+ *   const br = new BlockrunClient({ privateKey: "0x..." });
+ *
+ *   // Surf endpoint (Tier 1, $0.001)
+ *   const btc = await br.get("/v1/surf/market/price", { symbol: "BTC" });
+ *
+ *   // Raw on-chain SQL (Tier 3, $0.020)
+ *   const rows = await br.post("/v1/surf/onchain/sql", {
+ *     query: "SELECT block_number FROM ethereum.blocks ORDER BY block_number DESC LIMIT 1",
+ *   });
+ *
+ *   // Long-running video generation (submit + poll, paid on success)
+ *   const video = await br.poll("/v1/videos/generations", {
+ *     model: "xai/grok-imagine-video",
+ *     prompt: "a red apple spinning",
+ *   });
+ *
+ *   // Streaming chat
+ *   for await (const chunk of br.stream("/v1/chat/completions", {
+ *     model: "anthropic/claude-sonnet-4-6",
+ *     messages: [{ role: "user", content: "Hi" }],
+ *     stream: true,
+ *   })) {
+ *     process.stdout.write(chunk.choices?.[0]?.delta?.content ?? "");
+ *   }
+ */
+
+type QueryValue = string | number | boolean | null | undefined;
+type QueryParams = Record<string, QueryValue | QueryValue[]>;
+/**
+ * The x402-paying HTTP primitive for the BridgeNode gateway.
+ *
+ * One instance, one wallet, all endpoints. The four call shapes (get, post,
+ * poll, stream) cover every endpoint type the gateway exposes.
+ */
+declare class BlockrunClient {
+    private account;
+    private privateKey;
+    private apiUrl;
+    private timeout;
+    private sessionTotalUsd;
+    private sessionCalls;
+    constructor(options?: BridgeNodeClientOptions);
+    /**
+     * GET a BlockRun endpoint. `path` is everything after `/api` (a leading
+     * `/api` is tolerated and stripped). Query params are URL-encoded; arrays
+     * become repeated keys (`?a=1&a=2`); undefined/null are dropped.
+     */
+    get<T = unknown>(path: string, params?: QueryParams): Promise<T>;
+    /**
+     * POST a BlockRun endpoint with a JSON body.
+     */
+    post<T = unknown>(path: string, body?: Record<string, unknown>): Promise<T>;
+    /**
+     * Submit a long-running job and poll until it completes.
+     *
+     * Pattern: submit → 402 → sign → 202 `{ id, poll_url, status }` → loop GET
+     * the poll_url with the SAME `PAYMENT-SIGNATURE` until status=completed (or
+     * deadline exceeded). Settlement happens only when upstream returns 200 +
+     * completed — upstream failure or caller giving up = no charge.
+     *
+     * If the gateway returns 200 directly on submit (no async surface), this
+     * short-circuits and returns the body. Most long-running endpoints (image,
+     * video, music, voice) return 202 with a poll_url.
+     */
+    poll<T = unknown>(path: string, body?: Record<string, unknown>, options?: PollOptions): Promise<T>;
+    /**
+     * Stream a Server-Sent Events endpoint.
+     *
+     * Yields each `data: …` line parsed as JSON. Stops when the upstream emits
+     * `data: [DONE]` or closes the connection. Caller is responsible for typing
+     * the chunk shape; pass a generic for typed yields.
+     *
+     * Example — streaming chat:
+     *   for await (const chunk of br.stream<ChatChunk>("/v1/chat/completions", {
+     *     model: "anthropic/claude-sonnet-4-6",
+     *     messages: [{ role: "user", content: "Hi" }],
+     *     stream: true,
+     *   })) {
+     *     process.stdout.write(chunk.choices?.[0]?.delta?.content ?? "");
+     *   }
+     */
+    stream<T = unknown>(path: string, body?: Record<string, unknown>): AsyncGenerator<T, void, undefined>;
+    private buildUrl;
+    private absolute;
+    private requestWithPayment;
+    private handlePaymentAndRetry;
+    /**
+     * Read a 402 response's payment requirements (header or body), then sign and
+     * return the base64 PAYMENT-SIGNATURE payload. Also records the cost-to-be
+     * onto the response context (settled on `recordSpending`).
+     */
+    private signFrom402;
+    /** Accumulates the most-recent pending cost; settled by recordSpending. */
+    private pendingCostUsd;
+    private recordSpending;
+    private throwApiError;
+    private fetchWithTimeout;
+    getWalletAddress(): string;
+    getSpending(): Spending;
+}
+
+/**
+ * x402 Payment Protocol v2 Implementation for BlockRun.
+ *
+ * This module handles creating signed payment payloads for the x402 v2 protocol.
+ * The private key is used ONLY for local signing and NEVER leaves the client.
+ */
+
+declare const BASE_CHAIN_ID = 8453;
+declare const USDC_BASE: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+declare const SOLANA_NETWORK = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+declare const USDC_SOLANA = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+interface CreatePaymentOptions {
+    resourceUrl?: string;
+    resourceDescription?: string;
+    maxTimeoutSeconds?: number;
+    extra?: {
+        name?: string;
+        version?: string;
+    };
+    extensions?: Record<string, unknown>;
+}
+/**
+ * Create a signed x402 v2 payment payload.
+ *
+ * @param privateKey - Hex-encoded private key
+ * @param fromAddress - Sender wallet address
+ * @param recipient - Payment recipient address
+ * @param amount - Amount in micro USDC (6 decimals)
+ * @param network - Network identifier (default: eip155:8453)
+ * @param options - Additional options for resource info
+ * @returns Base64-encoded signed payment payload
+ */
+declare function createPaymentPayload(privateKey: `0x${string}`, fromAddress: string, recipient: string, amount: string, network?: string, options?: CreatePaymentOptions): Promise<string>;
+interface CreateSolanaPaymentOptions {
+    resourceUrl?: string;
+    resourceDescription?: string;
+    maxTimeoutSeconds?: number;
+    extra?: Record<string, unknown>;
+    extensions?: Record<string, unknown>;
+    rpcUrl?: string;
+    /**
+     * Optional HTTP headers forwarded to the Solana RPC endpoint
+     * (e.g. `{ "x-api-key": "..." }` for Tatum / header-auth gateways).
+     */
+    rpcHeaders?: Record<string, string>;
+}
+/**
+ * Create a signed Solana x402 v2 payment payload.
+ *
+ * This creates an SPL TransferChecked transaction for USDC payment
+ * that the CDP facilitator can verify and settle.
+ *
+ * Requires @solana/web3.js and @solana/spl-token dependencies.
+ *
+ * @param secretKey - Solana secret key (Uint8Array, 64 bytes)
+ * @param fromAddress - Sender wallet address (base58)
+ * @param recipient - Payment recipient address (base58)
+ * @param amount - Amount in micro USDC (6 decimals)
+ * @param feePayer - CDP facilitator fee payer address (base58)
+ * @param options - Additional options
+ * @returns Base64-encoded signed payment payload
+ */
+declare function createSolanaPaymentPayload(secretKey: Uint8Array, fromAddress: string, recipient: string, amount: string, feePayer: string, options?: CreateSolanaPaymentOptions): Promise<string>;
+/**
+ * Parse the PAYMENT-REQUIRED header from a 402 response.
+ *
+ * @param headerValue - Base64-encoded payment required header
+ * @returns Parsed payment required object
+ * @throws {Error} If the header cannot be parsed or has invalid structure
+ */
+declare function parsePaymentRequired(headerValue: string): PaymentRequired;
+/**
+ * Extract payment details from parsed payment required response.
+ * Supports both v1 and v2 formats, with optional network preference.
+ *
+ * @param paymentRequired - Parsed payment required object
+ * @param preferredNetwork - Optional network preference. If specified, will try
+ *   to use matching network option. Defaults to first option (Base).
+ *   Examples:
+ *   - "eip155:8453" for Base
+ *   - "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp" for Solana
+ */
+declare function extractPaymentDetails(paymentRequired: PaymentRequired, preferredNetwork?: string): {
+    amount: string;
+    recipient: string;
+    network: string;
+    asset: string;
+    scheme: string;
+    maxTimeoutSeconds: number;
+    extra?: {
+        name?: string;
+        version?: string;
+        feePayer?: string;
+    };
+    resource?: ResourceInfo;
+};
+
+/**
+ * BlockRun Wallet Management - Auto-create and manage wallets.
+ *
+ * Provides frictionless wallet setup for new users:
+ * - Auto-creates wallet if none exists
+ * - Stores key securely at ~/.bridgenode/.session
+ * - Generates EIP-681 URIs for easy MetaMask funding
+ */
+declare const USDC_BASE_CONTRACT = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+interface WalletInfo {
+    privateKey: string;
+    address: string;
+    isNew: boolean;
+}
+interface PaymentLinks {
+    basescan: string;
+    walletLink: string;
+    ethereum: string;
+    bridgenode: string;
+}
+/**
+ * Create a new Ethereum wallet.
+ *
+ * @returns Object with address and privateKey
+ */
+declare function createWallet(): {
+    address: string;
+    privateKey: string;
+};
+/**
+ * Save wallet private key to ~/.bridgenode/.session
+ *
+ * @param privateKey - Private key string (with 0x prefix)
+ * @returns Path to saved wallet file
+ */
+declare function saveWallet(privateKey: string): string;
+/**
+ * Discover ~/.<dir>/wallet.json files from other providers.
+ *
+ * Each file should contain JSON with "privateKey" and "address" fields.
+ * Results are sorted by modification time (most recent first). Discovery is
+ * intentionally opt-in: a provider wallet must never replace the canonical
+ * BlockRun wallet merely because it was written more recently.
+ *
+ * @returns Array of wallet objects with privateKey and address
+ */
+declare function scanWallets(): Array<{
+    privateKey: string;
+    address: string;
+    source: string;
+}>;
+/**
+ * List wallets from other applications, safe to show to a user.
+ *
+ * Unlike `scanWallets()`, no private key is returned and the address is derived
+ * from the key rather than read from the file, so a wallet file cannot claim an
+ * address it has no key for.
+ *
+ * Nothing here is active. Adopt one deliberately with `importWallet()`.
+ *
+ * @returns Discovered wallets as `{ address, source }`, most recent first
+ */
+declare function listDiscoveredWallets(): Array<{
+    address: string;
+    source: string;
+}>;
+/**
+ * Adopt a discovered wallet by address, making it the active BlockRun wallet.
+ *
+ * This is the deliberate migration path: automatic selection never adopts a
+ * discovered wallet, but you can choose one whose funds you want to spend.
+ * Matching is done against the address *derived from each discovered key*, so a
+ * wallet file claiming someone else's address can never be selected by it.
+ *
+ * The current `~/.bridgenode/.session` is backed up beside itself before being
+ * overwritten, so adopting a wallet can't strand the funds in the old one.
+ *
+ * @param address Address to adopt, as shown by `listDiscoveredWallets()`
+ * @returns The adopted address
+ * @throws If no discovered wallet derives to that address
+ */
+declare function importWallet(address: string): string;
+/**
+ * Load wallet private key from file.
+ *
+ * Priority:
+ * 1. ~/.bridgenode/.session
+ * 2. ~/.bridgenode/wallet.key (legacy)
+ *
+ * @returns Private key string or null if not found
+ */
+declare function loadWallet(): string | null;
+/**
+ * Warn when a new wallet was created while other provider wallets exist.
+ *
+ * Automatic selection deliberately ignores wallets discovered in other
+ * applications' directories, so a user who previously relied on that discovery
+ * would otherwise land on an empty wallet with no explanation of where their
+ * funds went. This notice names the discovered addresses and tells them how to
+ * import one on purpose.
+ *
+ * Addresses are derived from the discovered private key rather than read from
+ * the file's "address" field, so a file claiming an address it cannot sign for
+ * cannot trick the user into importing it.
+ *
+ * @param newAddress Address of the wallet that was just created
+ * @returns Formatted notice, or null if nothing was discovered
+ */
+declare function formatWalletMigrationNotice(newAddress: string): string | null;
+/**
+ * Get existing wallet or create new one.
+ *
+ * Priority:
+ * 1. BRIDGENODE_WALLET_KEY environment variable
+ * 2. ~/.bridgenode/.session file
+ * 3. ~/.bridgenode/wallet.key file - legacy
+ * 4. Create new wallet
+ *
+ * @returns WalletInfo with address, privateKey, and isNew flag
+ */
+declare function getOrCreateWallet(): WalletInfo;
+/**
+ * Get wallet address without exposing private key.
+ *
+ * @returns Wallet address or null if no wallet configured
+ */
+declare function getWalletAddress(): string | null;
+/**
+ * Generate EIP-681 URI for USDC transfer on Base.
+ *
+ * @param address - Recipient Ethereum address
+ * @param amountUsdc - Amount in USDC (default 1.0)
+ * @returns EIP-681 URI string for MetaMask/wallet scanning
+ */
+declare function getEip681Uri(address: string, amountUsdc?: number): string;
+/**
+ * Generate payment links for the wallet address.
+ *
+ * @param address - Ethereum address
+ * @returns Object with various payment links
+ */
+declare function getPaymentLinks(address: string): PaymentLinks;
+/**
+ * Format the message shown when a new wallet is created.
+ *
+ * @param address - New wallet address
+ * @returns Formatted message string
+ */
+declare function formatWalletCreatedMessage(address: string): string;
+/**
+ * Format the message shown when wallet needs more funds.
+ *
+ * @param address - Wallet address
+ * @returns Formatted message string
+ */
+declare function formatNeedsFundingMessage(address: string): string;
+/**
+ * Compact funding message (no QR) for repeated displays.
+ *
+ * @param address - Wallet address
+ * @returns Short formatted message string
+ */
+declare function formatFundingMessageCompact(address: string): string;
+declare const WALLET_FILE_PATH: string;
+declare const WALLET_DIR_PATH: string;
+
+/**
+ * BlockRun Solana LLM Client.
+ *
+ * Usage:
+ *   import { SolanaLLMClient } from '@blockrun/llm';
+ *
+ *   // SOLANA_WALLET_KEY env var (bs58-encoded Solana secret key)
+ *   const client = new SolanaLLMClient();
+ *
+ *   // Or pass key directly
+ *   const client = new SolanaLLMClient({ privateKey: 'your-bs58-key' });
+ *
+ *   const response = await client.chat('openai/gpt-5.2', 'gm Solana');
+ */
+
+interface SolanaLLMClientOptions {
+    /** bs58-encoded Solana secret key (64 bytes). Optional if SOLANA_WALLET_KEY env var is set. */
+    privateKey?: string;
+    /** API endpoint URL (default: https://sol.bridgenode.cc/api) */
+    apiUrl?: string;
+    /**
+     * Solana JSON-RPC URL. Defaults to BlockRun's own Tatum-backed proxy
+     * (`https://sol.bridgenode.cc/api/v1/solana/rpc`), free for SDK users.
+     * Override to point at your own Helius / Tatum / QuickNode account, or
+     * fall back to the env vars `SOLANA_RPC_URL` /
+     * `SOLANA_RPC_API_KEY` / `SOLANA_RPC_HEADERS`.
+     */
+    rpcUrl?: string;
+    /**
+     * Optional headers forwarded to the Solana RPC endpoint. Use this for
+     * header-auth gateways (Tatum's `x-api-key`, some Triton tiers). Falls
+     * back to `SOLANA_RPC_HEADERS` (JSON dict) or `SOLANA_RPC_API_KEY`
+     * (shortcut for `{ "x-api-key": "..." }`) env vars when omitted.
+     */
+    rpcHeaders?: Record<string, string>;
+    /** Request timeout in milliseconds (default: 60000) */
+    timeout?: number;
+}
+declare class SolanaLLMClient {
+    static readonly SOLANA_API_URL = "https://sol.bridgenode.cc/api";
+    private privateKey;
+    private apiUrl;
+    private rpcUrl;
+    private rpcHeaders?;
+    private timeout;
+    private sessionTotalUsd;
+    private sessionCalls;
+    private addressCache;
+    constructor(options?: SolanaLLMClientOptions);
+    /** Get Solana wallet address (public key in base58). */
+    getWalletAddress(): Promise<string>;
+    /** Simple 1-line chat. */
+    chat(model: string, prompt: string, options?: ChatOptions): Promise<string>;
+    /** Full chat completion (OpenAI-compatible). */
+    chatCompletion(model: string, messages: ChatMessage[], options?: ChatCompletionOptions): Promise<ChatResponse>;
+    /** List available models. */
+    listModels(): Promise<Model[]>;
+    /**
+     * Get Solana USDC balance.
+     *
+     * @returns USDC balance as a float
+     */
+    getBalance(): Promise<number>;
+    /** Edit an image using img2img (Solana payment). */
+    imageEdit(prompt: string, image: string | string[], options?: ImageEditOptions): Promise<ImageResponse>;
+    /** Standalone search (Solana payment). */
+    search(query: string, options?: SearchOptions): Promise<SearchResult>;
+    pm(path: string, params?: Record<string, string>): Promise<Record<string, unknown>>;
+    pmQuery(path: string, query: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /**
+     * Generic Exa endpoint proxy (POST, Solana payment). Powered by Exa.
+     *
+     * @param path - Exa endpoint: "search" | "find-similar" | "contents" | "answer"
+     * @param body - Request body (see Exa API docs)
+     *
+     * @example
+     * const results = await client.exa("search", { query: "latest AI research", numResults: 5 });
+     */
+    exa(path: string, body: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /**
+     * Neural and keyword web search via Exa (Solana payment, $0.01/request).
+     *
+     * @example
+     * const results = await client.exaSearch("latest AI papers", { numResults: 5 });
+     */
+    exaSearch(query: string, options?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /**
+     * Find pages semantically similar to a given URL via Exa (Solana payment, $0.01/request).
+     *
+     * @example
+     * const results = await client.exaFindSimilar("https://openai.com/research/gpt-4", { numResults: 5 });
+     */
+    exaFindSimilar(url: string, options?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /**
+     * Extract full text content from URLs via Exa (Solana payment, $0.002/URL).
+     *
+     * @example
+     * const data = await client.exaContents(["https://arxiv.org/abs/2303.08774"]);
+     */
+    exaContents(urls: string[], options?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /**
+     * AI-generated answer grounded in live web search via Exa (Solana payment, $0.01/request).
+     *
+     * @example
+     * const answer = await client.exaAnswer("What is the current state of AI safety research?");
+     */
+    exaAnswer(query: string, options?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /**
+     * Query DefiLlama DeFi data (GET passthrough). Powered by DefiLlama.
+     * $0.005/call for protocols / protocol/{slug} / chains / yields;
+     * $0.001/call for prices/{coins}.
+     *
+     * @param path - e.g. "protocols", "protocol/aave", "chains", "yields",
+     *               "prices/coingecko:bitcoin,base:0x..."
+     * @param params - Query parameters passed through to DefiLlama
+     */
+    defi(path: string, params?: Record<string, string>): Promise<Record<string, unknown>>;
+    /** All DeFi protocols with TVL ($0.005/call). */
+    defiProtocols(): Promise<Record<string, unknown>>;
+    /** Single protocol details + historical TVL ($0.005/call). */
+    defiProtocol(slug: string): Promise<Record<string, unknown>>;
+    /** Current TVL of every chain ($0.005/call). */
+    defiChains(): Promise<Record<string, unknown>>;
+    /** Yield pools with APY/TVL ($0.005/call). */
+    defiYields(params?: Record<string, string>): Promise<Record<string, unknown>>;
+    /** Token price lookup ($0.001/call). Coins like "coingecko:bitcoin" or "{chain}:{address}". */
+    defiPrices(coins: string | string[]): Promise<Record<string, unknown>>;
+    /**
+     * Query the 0x Swap / Gasless APIs (free — no x402 payment; BlockRun
+     * takes an on-chain affiliate fee on executed swaps instead).
+     *
+     * @param path - "price", "quote", "gasless/price", "gasless/quote",
+     *               "gasless/submit" (POST), "gasless/status/{hash}",
+     *               "gasless/approval-tokens", "gasless/chains", "swap/chains"
+     * @param params - Query params (chainId, sellToken, buyToken, sellAmount, taker, ...)
+     * @param body - JSON body — pass to switch to POST (gasless/submit only)
+     */
+    dex(path: string, params?: Record<string, string>, body?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Indicative Permit2 swap price — no commitment (free). */
+    dexPrice(params: Record<string, string>): Promise<Record<string, unknown>>;
+    /** Firm Permit2 swap quote with permit2.eip712 + tx data (free). */
+    dexQuote(params: Record<string, string>): Promise<Record<string, unknown>>;
+    /** Gasless indicative price quote (free). */
+    dexGaslessPrice(params: Record<string, string>): Promise<Record<string, unknown>>;
+    /** Gasless firm quote — returns trade.eip712 to sign (free). */
+    dexGaslessQuote(params: Record<string, string>): Promise<Record<string, unknown>>;
+    /** Submit a signed gasless trade; the 0x relayer pays gas (free). */
+    dexGaslessSubmit(body: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Poll a gasless trade's status by tradeHash (free). */
+    dexGaslessStatus(tradeHash: string): Promise<Record<string, unknown>>;
+    /** Chains where the Swap API is supported (free). */
+    dexChains(): Promise<Record<string, unknown>>;
+    /** Chains where the Gasless API is supported (free). */
+    dexGaslessChains(): Promise<Record<string, unknown>>;
+    /**
+     * Call the Modal sandbox compute API (POST passthrough).
+     *
+     * @param path - "sandbox/create" ($0.01 CPU / $0.05 GPU), "sandbox/exec",
+     *               "sandbox/status", "sandbox/terminate" ($0.001 each)
+     * @param body - JSON body for the endpoint
+     */
+    modal(path: string, body?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Create a sandboxed compute environment ($0.01 CPU / $0.05 GPU). */
+    modalSandboxCreate(body?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Execute a command in a sandbox; returns stdout/stderr ($0.001). */
+    modalSandboxExec(sandboxId: string, command: string[], extra?: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /** Check a sandbox's status ($0.001). */
+    modalSandboxStatus(sandboxId: string): Promise<Record<string, unknown>>;
+    /** Terminate a sandbox ($0.001). */
+    modalSandboxTerminate(sandboxId: string): Promise<Record<string, unknown>>;
+    /** Get session spending. */
+    getSpending(): Spending;
+    /** True if using sol.bridgenode.cc. */
+    isSolana(): boolean;
+    private requestWithPayment;
+    private handlePaymentAndRetry;
+    private requestWithPaymentRaw;
+    private handlePaymentAndRetryRaw;
+    private getWithPaymentRaw;
+    private handleGetPaymentAndRetryRaw;
+    private fetchWithTimeout;
+}
+/**
+ * Convenience function: create SolanaLLMClient for sol.bridgenode.cc.
+ */
+declare function solanaClient(options?: SolanaLLMClientOptions): SolanaLLMClient;
+
+declare const SOLANA_WALLET_FILE: string;
+interface SolanaWalletInfo {
+    privateKey: string;
+    address: string;
+    isNew: boolean;
+}
+/**
+ * Create a new Solana wallet.
+ * Requires @solana/web3.js (optional dep) — loaded lazily via dynamic
+ * import so callers that never touch Solana don't pay the resolution cost
+ * and ESM consumers don't trip over esbuild's __require shim.
+ */
+declare function createSolanaWallet(): Promise<{
+    address: string;
+    privateKey: string;
+}>;
+/**
+ * Convert a bs58 private key string to Uint8Array (64 bytes).
+ * Accepts: bs58-encoded 64-byte key (standard Solana format).
+ */
+declare function solanaKeyToBytes(privateKey: string): Promise<Uint8Array>;
+/**
+ * Get Solana public key (address) from bs58 private key.
+ */
+declare function solanaPublicKey(privateKey: string): Promise<string>;
+declare function saveSolanaWallet(privateKey: string): string;
+/**
+ * Discover ~/.<dir>/solana-wallet.json files from other providers.
+ *
+ * Each file should contain JSON with "privateKey" and "address" fields.
+ * Also checks ~/.brcc/wallet.json for BRCC wallets.
+ * Results are sorted by modification time (most recent first). Discovery is
+ * opt-in and never changes the active BlockRun wallet automatically.
+ *
+ * @returns Array of wallet objects with secretKey and publicKey
+ */
+declare function scanSolanaWallets(): Array<{
+    secretKey: string;
+    publicKey: string;
+    source: string;
+}>;
+declare function loadSolanaWallet(): string | null;
+/**
+ * List Solana wallets from other applications, safe to show to a user.
+ *
+ * Solana counterpart of `listDiscoveredWallets()`: no secret key is returned
+ * and the address is derived from the key rather than trusted from the file.
+ * Nothing here is active — adopt one with `importSolanaWallet()`.
+ *
+ * @returns Discovered wallets as `{ address, source }`, most recent first
+ */
+declare function listDiscoveredSolanaWallets(): Promise<Array<{
+    address: string;
+    source: string;
+}>>;
+/**
+ * Adopt a discovered Solana wallet, making it the active BlockRun wallet.
+ *
+ * Solana counterpart of `importWallet()`. Matching is done against the address
+ * derived from each discovered key, and the current
+ * `~/.bridgenode/.solana-session` is backed up before being overwritten.
+ *
+ * @param address Address to adopt, as shown by `listDiscoveredSolanaWallets()`
+ * @returns The adopted address
+ * @throws If no discovered wallet derives to that address
+ */
+declare function importSolanaWallet(address: string): Promise<string>;
+/**
+ * Warn when a new Solana wallet was created while provider wallets exist.
+ *
+ * Solana counterpart of `formatWalletMigrationNotice`. Addresses are derived
+ * from the discovered secret key rather than trusted from the file's "address"
+ * field.
+ *
+ * @param newAddress Address of the wallet that was just created
+ * @returns Formatted notice, or null if nothing was discovered
+ */
+declare function formatSolanaWalletMigrationNotice(newAddress: string): Promise<string | null>;
+declare function getOrCreateSolanaWallet(): Promise<SolanaWalletInfo>;
+
+declare function getCached(key: string): unknown | null;
+declare function getCachedByRequest(endpoint: string, body: Record<string, unknown>): unknown | null;
+declare function setCache(key: string, data: unknown, ttlMs: number): void;
+declare function saveToCache(endpoint: string, body: Record<string, unknown>, response: unknown, costUsd?: number): void;
+declare function clearCache(): number;
+declare function getCostLogSummary(): {
+    totalUsd: number;
+    calls: number;
+    byEndpoint: Record<string, number>;
+};
+
+/**
+ * Agent wallet setup utilities.
+ *
+ * Convenience functions for agent runtimes (Claude Code skills, etc.)
+ * that auto-create wallets and return configured clients.
+ */
+
+declare function setupAgentWallet(options?: {
+    silent?: boolean;
+}): LLMClient;
+declare function setupAgentSolanaWallet(options?: {
+    silent?: boolean;
+}): Promise<SolanaLLMClient>;
+declare function status(): Promise<{
+    address: string;
+    balance: number;
+}>;
+
+/** Canonical on-wire schema for cost_log.jsonl entries. */
+interface CostEntry {
+    /** Unix epoch seconds (float, millisecond precision). */
+    ts: number;
+    /** API endpoint path, e.g. "/v1/chat/completions". */
+    endpoint: string;
+    /** Settled USDC amount (USD, 6-decimal precision). */
+    cost_usd: number;
+    /** Model id when known, e.g. "zai/glm-5-turbo". Optional for non-LLM endpoints. */
+    model?: string;
+    /** Payer wallet address (EVM 0x... or Solana base58). */
+    wallet?: string;
+    /** Network identifier — "eip155:8453" for Base mainnet, "solana-mainnet", etc. */
+    network?: string;
+    /** Caller kind for analytics — "LLMClient", "ImageClient", "AgentClient", ... */
+    client_kind?: string;
+}
+declare function logCost(entry: CostEntry): void;
+declare function getCostSummary(): {
+    totalUsd: number;
+    calls: number;
+    byModel: Record<string, number>;
+    byEndpoint: Record<string, number>;
+};
+
+/**
+ * OpenAI-compatible API wrapper for BlockRun LLM SDK.
+ *
+ * Drop-in replacement for OpenAI SDK - just change the import and use walletKey instead of apiKey.
+ *
+ * @example
+ * // Before (OpenAI)
+ * import OpenAI from 'openai';
+ * const client = new OpenAI({ apiKey: 'sk-...' });
+ *
+ * // After (BlockRun)
+ * import { OpenAI } from '@blockrun/llm';
+ * const client = new OpenAI({ walletKey: '0x...' });
+ *
+ * // Rest of your code stays exactly the same!
+ * const response = await client.chat.completions.create({
+ *   model: 'gpt-5.2',
+ *   messages: [{ role: 'user', content: 'Hello!' }]
+ * });
+ */
+
+interface OpenAIClientOptions {
+    /** EVM wallet private key (replaces apiKey) */
+    walletKey?: `0x${string}` | string;
+    /** Alternative: use privateKey like LLMClient */
+    privateKey?: `0x${string}` | string;
+    /** API endpoint URL (default: https://bridgenode.cc/api) */
+    baseURL?: string;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+}
+interface OpenAIChatCompletionParams {
+    model: string;
+    messages: Array<{
+        role: "system" | "user" | "assistant" | "tool";
+        content?: string | null;
+        name?: string;
+        tool_call_id?: string;
+        tool_calls?: ToolCall[];
+    }>;
+    max_tokens?: number;
+    temperature?: number;
+    response_format?: ResponseFormat;
+    top_p?: number;
+    stream?: boolean;
+    n?: number;
+    stop?: string | string[];
+    presence_penalty?: number;
+    frequency_penalty?: number;
+    user?: string;
+    tools?: Tool[];
+    tool_choice?: ToolChoice;
+}
+interface OpenAIChatCompletionChoice {
+    index: number;
+    message: {
+        role: "assistant";
+        content?: string | null;
+        tool_calls?: ToolCall[];
+    };
+    finish_reason: "stop" | "length" | "content_filter" | "tool_calls" | null;
+}
+interface OpenAIChatCompletionResponse {
+    id: string;
+    object: "chat.completion";
+    created: number;
+    model: string;
+    choices: OpenAIChatCompletionChoice[];
+    usage?: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+interface OpenAIChatCompletionChunk {
+    id: string;
+    object: "chat.completion.chunk";
+    created: number;
+    model: string;
+    choices: Array<{
+        index: number;
+        delta: {
+            role?: "assistant";
+            content?: string;
+        };
+        finish_reason: string | null;
+    }>;
+}
+/**
+ * Chat completions API (OpenAI-compatible)
+ */
+declare class ChatCompletions {
+    private client;
+    private apiUrl;
+    private timeout;
+    constructor(client: LLMClient, apiUrl: string, timeout: number);
+    /**
+     * Create a chat completion (OpenAI-compatible).
+     */
+    create(params: OpenAIChatCompletionParams): Promise<OpenAIChatCompletionResponse>;
+    create(params: OpenAIChatCompletionParams & {
+        stream: true;
+    }): Promise<AsyncIterable<OpenAIChatCompletionChunk>>;
+    private createStream;
+    private transformResponse;
+}
+/**
+ * Chat API namespace
+ */
+declare class Chat {
+    completions: ChatCompletions;
+    constructor(client: LLMClient, apiUrl: string, timeout: number);
+}
+/**
+ * OpenAI-compatible client for BlockRun.
+ *
+ * Drop-in replacement for the OpenAI SDK.
+ *
+ * @example
+ * import { OpenAI } from '@blockrun/llm';
+ *
+ * const client = new OpenAI({ walletKey: '0x...' });
+ *
+ * const response = await client.chat.completions.create({
+ *   model: 'gpt-5.2',
+ *   messages: [{ role: 'user', content: 'Hello!' }]
+ * });
+ *
+ * console.log(response.choices[0].message.content);
+ */
+declare class OpenAI {
+    chat: Chat;
+    private client;
+    constructor(options?: OpenAIClientOptions);
+    /**
+     * Get the wallet address being used for payments.
+     */
+    getWalletAddress(): string;
+}
+
+interface BridgeNodeAnthropicOptions {
+    privateKey?: `0x${string}` | string;
+    apiUrl?: string;
+    timeout?: number;
+}
+declare class AnthropicClient {
+    private _client;
+    private _clientPromise;
+    private _privateKey;
+    private _account;
+    private _apiUrl;
+    private _timeout;
+    constructor(options?: BridgeNodeAnthropicOptions);
+    private _getClient;
+    private _x402Fetch;
+    get messages(): _anthropic_ai_sdk.default['messages'];
+    getWalletAddress(): string;
+}
+
+/**
+ * Input validation and security utilities for BlockRun LLM SDK.
+ *
+ * This module provides validation functions to ensure:
+ * - Private keys are properly formatted
+ * - API URLs use HTTPS
+ * - Server responses don't leak sensitive information
+ * - Resource URLs match expected domains
+ */
+
+/**
+ * Known LLM providers (for optional validation).
+ */
+declare const KNOWN_PROVIDERS: Set<string>;
+/**
+ * Validates that a model ID is a non-empty string.
+ *
+ * @param model - The model ID (e.g., "openai/gpt-5.2", "anthropic/claude-sonnet-4.5")
+ * @throws {Error} If the model is invalid
+ *
+ * @example
+ * validateModel("openai/gpt-5.2");
+ */
+declare function validateModel(model: string): void;
+/**
+ * Mirrors the gateway's own contract for `max_tokens`, which is exactly
+ * `z.number().int().min(1).optional()` — an integer, at least 1, and
+ * deliberately **no upper bound**.
+ *
+ * There is no ceiling here on purpose. The gateway clamps every request with
+ * `min(requested, model.maxOutput, contextHeadroom)` and then quotes only a
+ * fraction of the clamped value, so an oversized `maxTokens` cannot inflate a
+ * payment: 1e9 and 1_000_000 produce a byte-identical quote, because both land
+ * on the same `model.maxOutput`. A client-side ceiling could therefore only
+ * ever reject a request the gateway would have accepted and handled correctly.
+ *
+ * Earlier versions of this file did carry one, justified in a comment as
+ * stopping a stray 1e9 from "becoming a payment quote". That was never true —
+ * it was asserted here without being checked against the route handler, which
+ * is the same mistake as the old `"maxTokens too large (maximum: 100000)"`
+ * message that got recorded downstream as an upstream model ceiling. Verify
+ * against the gateway before reintroducing any number in this file.
+ *
+ * @param maxTokens - Maximum number of tokens to generate
+ * @throws {Error} If maxTokens is not a positive integer
+ *
+ * @example
+ * validateMaxTokens(1000);
+ */
+declare function validateMaxTokens(maxTokens?: number): void;
+/**
+ * Validates that temperature is a number between 0 and 2.
+ *
+ * @param temperature - Sampling temperature (0-2)
+ * @throws {Error} If temperature is invalid
+ *
+ * @example
+ * validateTemperature(0.7);
+ */
+declare function validateTemperature(temperature?: number): void;
+/**
+ * Validates that top_p is a number between 0 and 1.
+ *
+ * @param topP - Top-p sampling parameter (0-1)
+ * @throws {Error} If topP is invalid
+ *
+ * @example
+ * validateTopP(0.9);
+ */
+declare function validateTopP(topP?: number): void;
+
+export { APIError, AnthropicClient, type AudioModel, type AudioTrack, BASE_CHAIN_ID, type BarResolution, type BridgeNodeAnthropicOptions, BlockrunClient as BridgeNodeClient, type BridgeNodeClientOptions, BridgeNodeError, type CallInitiatedResponse, type CallModel, type CallOptions, type CallStatusResponse, type ChatChoice, type ChatCompletionOptions, type ChatMessage, type ChatOptions, type ChatResponse, type ChatResponseWithCost, type ChatUsage, type CostEntry, type CostEstimate, type CreatePaymentOptions, type FunctionCall, type FunctionDefinition, type HistoryOptions, ImageClient, type ImageClientOptions, type ImageData, type ImageEditOptions, type ImageGenerateOptions, type ImageModel, type ImageResponse, KNOWN_PROVIDERS, LLMClient, type LLMClientOptions, type ListOptions, type MarketSession, type Model, MusicClient, type MusicClientOptions, type MusicGenerateOptions, type MusicResponse, NETWORK_ALIASES, type NewsSearchSource, OpenAI, type OpenAIChatCompletionChoice, type OpenAIChatCompletionChunk, type OpenAIChatCompletionParams, type OpenAIChatCompletionResponse, type OpenAIClientOptions, PHONE_PRICES, PORTRAIT_ENROLLMENT_PRICE_USD, PaymentError, type PaymentLinks, type PhoneBuyOptions, type PhoneBuyResponse, PhoneClient, type PhoneClientOptions, type PhoneListResponse, type PhoneLookupResponse, type PhoneNumberRecord, type PhoneReleaseResponse, type PhoneRenewResponse, type PollOptions, PortraitClient, type PortraitClientOptions, type PortraitEnrollOptions, type PortraitEnrollResponse, type PriceBar, type PriceCategory, PriceClient, type PriceClientOptions, type PriceHistoryResponse, type PriceOptions, type PricePoint, RPC_PRICE_USD, type ResponseFormat, type RoutingDecision, type RoutingProfile, type RoutingTier, type RpcBatchRequest, RpcClient, type RpcClientOptions, type RpcError, type RpcNetwork, type RpcResponse, type RssSearchSource, SOLANA_NETWORK, SOLANA_WALLET_FILE as SOLANA_WALLET_FILE_PATH, SUPPORTED_NETWORKS, SearchClient, type SearchClientOptions, type SearchOptions, type SearchParameters, type SearchResult, type SearchSource, type SearchUsage, type SmartChatOptions, type SmartChatResponse, SolanaLLMClient, type SolanaLLMClientOptions, type SolanaWalletInfo, type SoundEffectOptions, type SpeechAudio, SpeechClient, type SpeechClientOptions, type SpeechGenerateOptions, type SpeechModel, type SpeechResponse, type SpeechVoice, type Spending, type SpendingReport, type StockMarket, SurfClient, type SurfClientOptions, type SymbolListResponse, type Tool, type ToolCall, type ToolChoice, USDC_BASE, USDC_BASE_CONTRACT, USDC_SOLANA, VideoClient, type VideoClientOptions, type VideoClip, type VideoGenerateOptions, type VideoModel, type VideoResponse, VoiceClient, type VoiceClientOptions, type VoiceInfo, type VoicePreset, WALLET_DIR_PATH, WALLET_FILE_PATH, type WalletInfo, type WebSearchSource, type XSearchSource, clearCache, createPaymentPayload, createSolanaPaymentPayload, createSolanaWallet, createWallet, LLMClient as default, extractPaymentDetails, formatFundingMessageCompact, formatNeedsFundingMessage, formatSolanaWalletMigrationNotice, formatWalletCreatedMessage, formatWalletMigrationNotice, getCached, getCachedByRequest, getCostLogSummary, getCostSummary, getEip681Uri, getOrCreateSolanaWallet, getOrCreateWallet, getPaymentLinks, getWalletAddress, importSolanaWallet, importWallet, listDiscoveredSolanaWallets, listDiscoveredWallets, loadSolanaWallet, loadWallet, logCost, parsePaymentRequired, saveSolanaWallet, saveToCache, saveWallet, scanSolanaWallets, scanWallets, setCache, setupAgentSolanaWallet, setupAgentWallet, solanaClient, solanaKeyToBytes, solanaPublicKey, status, validateMaxTokens, validateModel, validateTemperature, validateTopP };