hybrid 1.2.8 → 1.3.0

package/dist/index-CWnGnicw.d.cts

@@ -0,0 +1,1927 @@
+import { z } from 'zod';
+import { UIMessage } from 'ai';
+import { XmtpConversation, XmtpMessage, XmtpSender, XmtpSubjects, XmtpServiceClient } from '@hybrd/xmtp';
+import * as viem_chains from 'viem/chains';
+import * as viem from 'viem';
+
+interface BaseRuntime extends Record<string, unknown> {
+    conversation: XmtpConversation;
+    message: XmtpMessage;
+    parentMessage?: XmtpMessage;
+    rootMessage: XmtpMessage;
+    sender: XmtpSender;
+    subjects: XmtpSubjects;
+    xmtpClient: XmtpServiceClient;
+}
+type AgentRuntime = BaseRuntime & {
+    chatId?: string;
+    messages: Array<UIMessage>;
+};
+interface XmtpCredentials {
+    inboxId: string;
+    xmtpServiceUrl: string;
+    xmtpServiceToken: string;
+}
+
+type DefaultRuntimeExtension = Record<string, never>;
+/**
+ * Configuration interface for creating custom tools that integrate with AI SDK.
+ */
+interface ToolConfig<TInput extends z.ZodTypeAny = z.ZodTypeAny, TOutput extends z.ZodTypeAny = z.ZodTypeAny, TRuntimeExtension = DefaultRuntimeExtension> {
+    /** Unique identifier for the tool */
+    id: string;
+    /** Human-readable description of what the tool does */
+    description: string;
+    /** Zod schema for validating tool input */
+    inputSchema: TInput;
+    /** Optional Zod schema for validating tool output */
+    outputSchema?: TOutput;
+    /** Function that executes the tool's logic */
+    execute: (args: {
+        input: z.infer<TInput>;
+        runtime: AgentRuntime & TRuntimeExtension;
+        messages: UIMessage[];
+    }) => Promise<z.infer<TOutput>>;
+}
+/**
+ * Internal tool interface used throughout the agent framework.
+ * Similar to ToolConfig but without the ID field, used after tool creation.
+ */
+interface Tool<TInput extends z.ZodTypeAny = z.ZodTypeAny, TOutput extends z.ZodTypeAny = z.ZodTypeAny, TRuntimeExtension = DefaultRuntimeExtension> {
+    /** Human-readable description of what the tool does */
+    description: string;
+    /** Zod schema for validating tool input */
+    inputSchema: TInput;
+    /** Optional Zod schema for validating tool output */
+    outputSchema?: TOutput;
+    /** Function that executes the tool's logic */
+    execute: (args: {
+        input: z.infer<TInput>;
+        runtime: AgentRuntime & TRuntimeExtension;
+        messages: UIMessage[];
+    }) => Promise<z.infer<TOutput>>;
+}
+/**
+ * Factory function to create tools with custom runtime extensions.
+ * Provides proper type inference for input/output schemas and runtime extensions.
+ */
+declare function toolFactory<TRuntimeExtension = DefaultRuntimeExtension>(): <TInput extends z.ZodTypeAny, TOutput extends z.ZodTypeAny = z.ZodTypeAny>(config: ToolConfig<TInput, TOutput, TRuntimeExtension>) => Tool<TInput, TOutput, TRuntimeExtension>;
+/**
+ * Default tool factory with no runtime extensions.
+ * Type-safe at creation time with proper schema inference.
+ */
+declare const createTool: <TInput extends z.ZodTypeAny, TOutput extends z.ZodTypeAny = z.ZodTypeAny>(config: ToolConfig<TInput, TOutput, DefaultRuntimeExtension>) => Tool<TInput, TOutput, DefaultRuntimeExtension>;
+
+declare const SUPPORTED_CHAINS: {
+    readonly mainnet: {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Etherscan";
+                readonly url: "https://etherscan.io";
+                readonly apiUrl: "https://api.etherscan.io/api";
+            };
+        };
+        blockTime: 12000;
+        contracts: {
+            readonly ensRegistry: {
+                readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
+            };
+            readonly ensUniversalResolver: {
+                readonly address: "0xce01f8eee7E479C928F8919abD53E553a36CeF67";
+                readonly blockCreated: 19258213;
+            };
+            readonly multicall3: {
+                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                readonly blockCreated: 14353601;
+            };
+        };
+        ensTlds?: readonly string[] | undefined;
+        id: 1;
+        name: "Ethereum";
+        nativeCurrency: {
+            readonly name: "Ether";
+            readonly symbol: "ETH";
+            readonly decimals: 18;
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://eth.merkle.io"];
+            };
+        };
+        sourceId?: number | undefined | undefined;
+        testnet?: boolean | undefined | undefined;
+        custom?: Record<string, unknown> | undefined;
+        fees?: viem.ChainFees<undefined> | undefined;
+        formatters?: undefined;
+        serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+    };
+    readonly sepolia: {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Etherscan";
+                readonly url: "https://sepolia.etherscan.io";
+                readonly apiUrl: "https://api-sepolia.etherscan.io/api";
+            };
+        };
+        blockTime?: number | undefined | undefined;
+        contracts: {
+            readonly multicall3: {
+                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                readonly blockCreated: 751532;
+            };
+            readonly ensRegistry: {
+                readonly address: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
+            };
+            readonly ensUniversalResolver: {
+                readonly address: "0xc8Af999e38273D658BE1b921b88A9Ddf005769cC";
+                readonly blockCreated: 5317080;
+            };
+        };
+        ensTlds?: readonly string[] | undefined;
+        id: 11155111;
+        name: "Sepolia";
+        nativeCurrency: {
+            readonly name: "Sepolia Ether";
+            readonly symbol: "ETH";
+            readonly decimals: 18;
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://sepolia.drpc.org"];
+            };
+        };
+        sourceId?: number | undefined | undefined;
+        testnet: true;
+        custom?: Record<string, unknown> | undefined;
+        fees?: viem.ChainFees<undefined> | undefined;
+        formatters?: undefined;
+        serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+    };
+    readonly polygon: {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "PolygonScan";
+                readonly url: "https://polygonscan.com";
+                readonly apiUrl: "https://api.polygonscan.com/api";
+            };
+        };
+        blockTime?: number | undefined | undefined;
+        contracts: {
+            readonly multicall3: {
+                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                readonly blockCreated: 25770160;
+            };
+        };
+        ensTlds?: readonly string[] | undefined;
+        id: 137;
+        name: "Polygon";
+        nativeCurrency: {
+            readonly name: "POL";
+            readonly symbol: "POL";
+            readonly decimals: 18;
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://polygon-rpc.com"];
+            };
+        };
+        sourceId?: number | undefined | undefined;
+        testnet?: boolean | undefined | undefined;
+        custom?: Record<string, unknown> | undefined;
+        fees?: viem.ChainFees<undefined> | undefined;
+        formatters?: undefined;
+        serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+    };
+    readonly arbitrum: {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Arbiscan";
+                readonly url: "https://arbiscan.io";
+                readonly apiUrl: "https://api.arbiscan.io/api";
+            };
+        };
+        blockTime: 250;
+        contracts: {
+            readonly multicall3: {
+                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                readonly blockCreated: 7654707;
+            };
+        };
+        ensTlds?: readonly string[] | undefined;
+        id: 42161;
+        name: "Arbitrum One";
+        nativeCurrency: {
+            readonly name: "Ether";
+            readonly symbol: "ETH";
+            readonly decimals: 18;
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://arb1.arbitrum.io/rpc"];
+            };
+        };
+        sourceId?: number | undefined | undefined;
+        testnet?: boolean | undefined | undefined;
+        custom?: Record<string, unknown> | undefined;
+        fees?: viem.ChainFees<undefined> | undefined;
+        formatters?: undefined;
+        serializers?: viem.ChainSerializers<undefined, viem.TransactionSerializable> | undefined;
+    };
+    readonly optimism: {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Optimism Explorer";
+                readonly url: "https://optimistic.etherscan.io";
+                readonly apiUrl: "https://api-optimistic.etherscan.io/api";
+            };
+        };
+        blockTime: 2000;
+        contracts: {
+            readonly disputeGameFactory: {
+                readonly 1: {
+                    readonly address: "0xe5965Ab5962eDc7477C8520243A95517CD252fA9";
+                };
+            };
+            readonly l2OutputOracle: {
+                readonly 1: {
+                    readonly address: "0xdfe97868233d1aa22e815a266982f2cf17685a27";
+                };
+            };
+            readonly multicall3: {
+                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                readonly blockCreated: 4286263;
+            };
+            readonly portal: {
+                readonly 1: {
+                    readonly address: "0xbEb5Fc579115071764c7423A4f12eDde41f106Ed";
+                };
+            };
+            readonly l1StandardBridge: {
+                readonly 1: {
+                    readonly address: "0x99C9fc46f92E8a1c0deC1b1747d010903E884bE1";
+                };
+            };
+            readonly gasPriceOracle: {
+                readonly address: "0x420000000000000000000000000000000000000F";
+            };
+            readonly l1Block: {
+                readonly address: "0x4200000000000000000000000000000000000015";
+            };
+            readonly l2CrossDomainMessenger: {
+                readonly address: "0x4200000000000000000000000000000000000007";
+            };
+            readonly l2Erc721Bridge: {
+                readonly address: "0x4200000000000000000000000000000000000014";
+            };
+            readonly l2StandardBridge: {
+                readonly address: "0x4200000000000000000000000000000000000010";
+            };
+            readonly l2ToL1MessagePasser: {
+                readonly address: "0x4200000000000000000000000000000000000016";
+            };
+        };
+        ensTlds?: readonly string[] | undefined;
+        id: 10;
+        name: "OP Mainnet";
+        nativeCurrency: {
+            readonly name: "Ether";
+            readonly symbol: "ETH";
+            readonly decimals: 18;
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://mainnet.optimism.io"];
+            };
+        };
+        sourceId: 1;
+        testnet?: boolean | undefined | undefined;
+        custom?: Record<string, unknown> | undefined;
+        fees?: viem.ChainFees<undefined> | undefined;
+        formatters: {
+            readonly block: {
+                exclude: [] | undefined;
+                format: (args: viem_chains.OpStackRpcBlock) => {
+                    baseFeePerGas: bigint | null;
+                    blobGasUsed: bigint;
+                    difficulty: bigint;
+                    excessBlobGas: bigint;
+                    extraData: viem.Hex;
+                    gasLimit: bigint;
+                    gasUsed: bigint;
+                    hash: `0x${string}` | null;
+                    logsBloom: `0x${string}` | null;
+                    miner: `0x${string}`;
+                    mixHash: viem.Hash;
+                    nonce: `0x${string}` | null;
+                    number: bigint | null;
+                    parentBeaconBlockRoot?: `0x${string}` | undefined;
+                    parentHash: viem.Hash;
+                    receiptsRoot: viem.Hex;
+                    sealFields: viem.Hex[];
+                    sha3Uncles: viem.Hash;
+                    size: bigint;
+                    stateRoot: viem.Hash;
+                    timestamp: bigint;
+                    totalDifficulty: bigint | null;
+                    transactions: `0x${string}`[] | viem_chains.OpStackTransaction<boolean>[];
+                    transactionsRoot: viem.Hash;
+                    uncles: viem.Hash[];
+                    withdrawals?: viem.Withdrawal[] | undefined | undefined;
+                    withdrawalsRoot?: `0x${string}` | undefined;
+                } & {};
+                type: "block";
+            };
+            readonly transaction: {
+                exclude: [] | undefined;
+                format: (args: viem_chains.OpStackRpcTransaction) => ({
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: `0x${string}`;
+                    gas: bigint;
+                    hash: viem.Hash;
+                    input: viem.Hex;
+                    nonce: number;
+                    r: viem.Hex;
+                    s: viem.Hex;
+                    to: `0x${string}` | null;
+                    transactionIndex: number | null;
+                    typeHex: viem.Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: boolean;
+                    mint?: bigint | undefined | undefined;
+                    sourceHash: viem.Hex;
+                    type: "deposit";
+                } | {
+                    r: viem.Hex;
+                    s: viem.Hex;
+                    v: bigint;
+                    to: `0x${string}` | null;
+                    from: `0x${string}`;
+                    gas: bigint;
+                    nonce: number;
+                    value: bigint;
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    hash: viem.Hash;
+                    input: viem.Hex;
+                    transactionIndex: number | null;
+                    typeHex: viem.Hex | null;
+                    accessList?: undefined | undefined;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId?: number | undefined;
+                    yParity?: undefined | undefined;
+                    type: "legacy";
+                    gasPrice: bigint;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas?: undefined | undefined;
+                    maxPriorityFeePerGas?: undefined | undefined;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: `0x${string}`;
+                    gas: bigint;
+                    hash: viem.Hash;
+                    input: viem.Hex;
+                    nonce: number;
+                    r: viem.Hex;
+                    s: viem.Hex;
+                    to: `0x${string}` | null;
+                    transactionIndex: number | null;
+                    typeHex: viem.Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: viem.AccessList;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId: number;
+                    type: "eip2930";
+                    gasPrice: bigint;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas?: undefined | undefined;
+                    maxPriorityFeePerGas?: undefined | undefined;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: `0x${string}`;
+                    gas: bigint;
+                    hash: viem.Hash;
+                    input: viem.Hex;
+                    nonce: number;
+                    r: viem.Hex;
+                    s: viem.Hex;
+                    to: `0x${string}` | null;
+                    transactionIndex: number | null;
+                    typeHex: viem.Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: viem.AccessList;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId: number;
+                    type: "eip1559";
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: `0x${string}`;
+                    gas: bigint;
+                    hash: viem.Hash;
+                    input: viem.Hex;
+                    nonce: number;
+                    r: viem.Hex;
+                    s: viem.Hex;
+                    to: `0x${string}` | null;
+                    transactionIndex: number | null;
+                    typeHex: viem.Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: viem.AccessList;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes: readonly viem.Hex[];
+                    chainId: number;
+                    type: "eip4844";
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas: bigint;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: `0x${string}`;
+                    gas: bigint;
+                    hash: viem.Hash;
+                    input: viem.Hex;
+                    nonce: number;
+                    r: viem.Hex;
+                    s: viem.Hex;
+                    to: `0x${string}` | null;
+                    transactionIndex: number | null;
+                    typeHex: viem.Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: viem.AccessList;
+                    authorizationList: viem.SignedAuthorizationList;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId: number;
+                    type: "eip7702";
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                }) & {};
+                type: "transaction";
+            };
+            readonly transactionReceipt: {
+                exclude: [] | undefined;
+                format: (args: viem_chains.OpStackRpcTransactionReceipt) => {
+                    blobGasPrice?: bigint | undefined;
+                    blobGasUsed?: bigint | undefined;
+                    blockHash: viem.Hash;
+                    blockNumber: bigint;
+                    contractAddress: `0x${string}` | null | undefined;
+                    cumulativeGasUsed: bigint;
+                    effectiveGasPrice: bigint;
+                    from: `0x${string}`;
+                    gasUsed: bigint;
+                    logs: viem.Log<bigint, number, false>[];
+                    logsBloom: viem.Hex;
+                    root?: `0x${string}` | undefined;
+                    status: "success" | "reverted";
+                    to: `0x${string}` | null;
+                    transactionHash: viem.Hash;
+                    transactionIndex: number;
+                    type: viem.TransactionType;
+                    l1GasPrice: bigint | null;
+                    l1GasUsed: bigint | null;
+                    l1Fee: bigint | null;
+                    l1FeeScalar: number | null;
+                } & {};
+                type: "transactionReceipt";
+            };
+        };
+        serializers: {
+            readonly transaction: typeof viem_chains.serializeTransactionOpStack;
+        };
+    };
+    readonly base: {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Basescan";
+                readonly url: "https://basescan.org";
+                readonly apiUrl: "https://api.basescan.org/api";
+            };
+        };
+        blockTime: 2000;
+        contracts: {
+            readonly disputeGameFactory: {
+                readonly 1: {
+                    readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
+                };
+            };
+            readonly l2OutputOracle: {
+                readonly 1: {
+                    readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
+                };
+            };
+            readonly multicall3: {
+                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                readonly blockCreated: 5022;
+            };
+            readonly portal: {
+                readonly 1: {
+                    readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
+                    readonly blockCreated: 17482143;
+                };
+            };
+            readonly l1StandardBridge: {
+                readonly 1: {
+                    readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
+                    readonly blockCreated: 17482143;
+                };
+            };
+            readonly gasPriceOracle: {
+                readonly address: "0x420000000000000000000000000000000000000F";
+            };
+            readonly l1Block: {
+                readonly address: "0x4200000000000000000000000000000000000015";
+            };
+            readonly l2CrossDomainMessenger: {
+                readonly address: "0x4200000000000000000000000000000000000007";
+            };
+            readonly l2Erc721Bridge: {
+                readonly address: "0x4200000000000000000000000000000000000014";
+            };
+            readonly l2StandardBridge: {
+                readonly address: "0x4200000000000000000000000000000000000010";
+            };
+            readonly l2ToL1MessagePasser: {
+                readonly address: "0x4200000000000000000000000000000000000016";
+            };
+        };
+        ensTlds?: readonly string[] | undefined;
+        id: 8453;
+        name: "Base";
+        nativeCurrency: {
+            readonly name: "Ether";
+            readonly symbol: "ETH";
+            readonly decimals: 18;
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://mainnet.base.org"];
+            };
+        };
+        sourceId: 1;
+        testnet?: boolean | undefined | undefined;
+        custom?: Record<string, unknown> | undefined;
+        fees?: viem.ChainFees<undefined> | undefined;
+        formatters: {
+            readonly block: {
+                exclude: [] | undefined;
+                format: (args: viem_chains.OpStackRpcBlock) => {
+                    baseFeePerGas: bigint | null;
+                    blobGasUsed: bigint;
+                    difficulty: bigint;
+                    excessBlobGas: bigint;
+                    extraData: viem.Hex;
+                    gasLimit: bigint;
+                    gasUsed: bigint;
+                    hash: `0x${string}` | null;
+                    logsBloom: `0x${string}` | null;
+                    miner: `0x${string}`;
+                    mixHash: viem.Hash;
+                    nonce: `0x${string}` | null;
+                    number: bigint | null;
+                    parentBeaconBlockRoot?: `0x${string}` | undefined;
+                    parentHash: viem.Hash;
+                    receiptsRoot: viem.Hex;
+                    sealFields: viem.Hex[];
+                    sha3Uncles: viem.Hash;
+                    size: bigint;
+                    stateRoot: viem.Hash;
+                    timestamp: bigint;
+                    totalDifficulty: bigint | null;
+                    transactions: `0x${string}`[] | viem_chains.OpStackTransaction<boolean>[];
+                    transactionsRoot: viem.Hash;
+                    uncles: viem.Hash[];
+                    withdrawals?: viem.Withdrawal[] | undefined | undefined;
+                    withdrawalsRoot?: `0x${string}` | undefined;
+                } & {};
+                type: "block";
+            };
+            readonly transaction: {
+                exclude: [] | undefined;
+                format: (args: viem_chains.OpStackRpcTransaction) => ({
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: `0x${string}`;
+                    gas: bigint;
+                    hash: viem.Hash;
+                    input: viem.Hex;
+                    nonce: number;
+                    r: viem.Hex;
+                    s: viem.Hex;
+                    to: `0x${string}` | null;
+                    transactionIndex: number | null;
+                    typeHex: viem.Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: boolean;
+                    mint?: bigint | undefined | undefined;
+                    sourceHash: viem.Hex;
+                    type: "deposit";
+                } | {
+                    r: viem.Hex;
+                    s: viem.Hex;
+                    v: bigint;
+                    to: `0x${string}` | null;
+                    from: `0x${string}`;
+                    gas: bigint;
+                    nonce: number;
+                    value: bigint;
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    hash: viem.Hash;
+                    input: viem.Hex;
+                    transactionIndex: number | null;
+                    typeHex: viem.Hex | null;
+                    accessList?: undefined | undefined;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId?: number | undefined;
+                    yParity?: undefined | undefined;
+                    type: "legacy";
+                    gasPrice: bigint;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas?: undefined | undefined;
+                    maxPriorityFeePerGas?: undefined | undefined;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: `0x${string}`;
+                    gas: bigint;
+                    hash: viem.Hash;
+                    input: viem.Hex;
+                    nonce: number;
+                    r: viem.Hex;
+                    s: viem.Hex;
+                    to: `0x${string}` | null;
+                    transactionIndex: number | null;
+                    typeHex: viem.Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: viem.AccessList;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId: number;
+                    type: "eip2930";
+                    gasPrice: bigint;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas?: undefined | undefined;
+                    maxPriorityFeePerGas?: undefined | undefined;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: `0x${string}`;
+                    gas: bigint;
+                    hash: viem.Hash;
+                    input: viem.Hex;
+                    nonce: number;
+                    r: viem.Hex;
+                    s: viem.Hex;
+                    to: `0x${string}` | null;
+                    transactionIndex: number | null;
+                    typeHex: viem.Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: viem.AccessList;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId: number;
+                    type: "eip1559";
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: `0x${string}`;
+                    gas: bigint;
+                    hash: viem.Hash;
+                    input: viem.Hex;
+                    nonce: number;
+                    r: viem.Hex;
+                    s: viem.Hex;
+                    to: `0x${string}` | null;
+                    transactionIndex: number | null;
+                    typeHex: viem.Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: viem.AccessList;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes: readonly viem.Hex[];
+                    chainId: number;
+                    type: "eip4844";
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas: bigint;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: `0x${string}`;
+                    gas: bigint;
+                    hash: viem.Hash;
+                    input: viem.Hex;
+                    nonce: number;
+                    r: viem.Hex;
+                    s: viem.Hex;
+                    to: `0x${string}` | null;
+                    transactionIndex: number | null;
+                    typeHex: viem.Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: viem.AccessList;
+                    authorizationList: viem.SignedAuthorizationList;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId: number;
+                    type: "eip7702";
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                }) & {};
+                type: "transaction";
+            };
+            readonly transactionReceipt: {
+                exclude: [] | undefined;
+                format: (args: viem_chains.OpStackRpcTransactionReceipt) => {
+                    blobGasPrice?: bigint | undefined;
+                    blobGasUsed?: bigint | undefined;
+                    blockHash: viem.Hash;
+                    blockNumber: bigint;
+                    contractAddress: `0x${string}` | null | undefined;
+                    cumulativeGasUsed: bigint;
+                    effectiveGasPrice: bigint;
+                    from: `0x${string}`;
+                    gasUsed: bigint;
+                    logs: viem.Log<bigint, number, false>[];
+                    logsBloom: viem.Hex;
+                    root?: `0x${string}` | undefined;
+                    status: "success" | "reverted";
+                    to: `0x${string}` | null;
+                    transactionHash: viem.Hash;
+                    transactionIndex: number;
+                    type: viem.TransactionType;
+                    l1GasPrice: bigint | null;
+                    l1GasUsed: bigint | null;
+                    l1Fee: bigint | null;
+                    l1FeeScalar: number | null;
+                } & {};
+                type: "transactionReceipt";
+            };
+        };
+        serializers: {
+            readonly transaction: typeof viem_chains.serializeTransactionOpStack;
+        };
+    };
+};
+type SupportedChain = keyof typeof SUPPORTED_CHAINS;
+interface BlockchainRuntimeExtension {
+    rpcUrl?: string;
+    privateKey?: string;
+    defaultChain?: SupportedChain;
+}
+/**
+ * Get Balance Tool
+ *
+ * Retrieves the native token balance for a given address on a specified chain.
+ *
+ * @tool getBalance
+ * @category Blockchain
+ *
+ * @param {string} address - The wallet address to check balance for
+ * @param {string} [chain] - The blockchain network (defaults to mainnet)
+ *
+ * @returns {Promise<{success: boolean, balance: string, balanceWei: string, address: string, chain: string, error?: string}>}
+ */
+declare const getBalanceTool: Tool<z.ZodObject<{
+    address: z.ZodString;
+    chain: z.ZodDefault<z.ZodEnum<["mainnet", "sepolia", "polygon", "arbitrum", "optimism", "base"]>>;
+}, "strip", z.ZodTypeAny, {
+    chain: "mainnet" | "sepolia" | "polygon" | "arbitrum" | "optimism" | "base";
+    address: string;
+}, {
+    address: string;
+    chain?: "mainnet" | "sepolia" | "polygon" | "arbitrum" | "optimism" | "base" | undefined;
+}>, z.ZodObject<{
+    success: z.ZodBoolean;
+    balance: z.ZodString;
+    balanceWei: z.ZodString;
+    address: z.ZodString;
+    chain: z.ZodString;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    chain: string;
+    address: string;
+    success: boolean;
+    balance: string;
+    balanceWei: string;
+    error?: string | undefined;
+}, {
+    chain: string;
+    address: string;
+    success: boolean;
+    balance: string;
+    balanceWei: string;
+    error?: string | undefined;
+}>, {
+    [x: string]: never;
+}>;
+/**
+ * Get Transaction Tool
+ *
+ * Retrieves transaction details by transaction hash.
+ *
+ * @tool getTransaction
+ * @category Blockchain
+ *
+ * @param {string} hash - The transaction hash to look up
+ * @param {string} [chain] - The blockchain network (defaults to mainnet)
+ *
+ * @returns {Promise<{success: boolean, transaction?: object, error?: string}>}
+ */
+declare const getTransactionTool: Tool<z.ZodObject<{
+    hash: z.ZodString;
+    chain: z.ZodDefault<z.ZodEnum<["mainnet", "sepolia", "polygon", "arbitrum", "optimism", "base"]>>;
+}, "strip", z.ZodTypeAny, {
+    chain: "mainnet" | "sepolia" | "polygon" | "arbitrum" | "optimism" | "base";
+    hash: string;
+}, {
+    hash: string;
+    chain?: "mainnet" | "sepolia" | "polygon" | "arbitrum" | "optimism" | "base" | undefined;
+}>, z.ZodObject<{
+    success: z.ZodBoolean;
+    transaction: z.ZodOptional<z.ZodObject<{
+        hash: z.ZodString;
+        from: z.ZodString;
+        to: z.ZodNullable<z.ZodString>;
+        value: z.ZodString;
+        gasUsed: z.ZodOptional<z.ZodString>;
+        gasPrice: z.ZodOptional<z.ZodString>;
+        blockNumber: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        from: string;
+        hash: string;
+        to: string | null;
+        value: string;
+        status?: string | undefined;
+        blockNumber?: string | undefined;
+        gasPrice?: string | undefined;
+        gasUsed?: string | undefined;
+    }, {
+        from: string;
+        hash: string;
+        to: string | null;
+        value: string;
+        status?: string | undefined;
+        blockNumber?: string | undefined;
+        gasPrice?: string | undefined;
+        gasUsed?: string | undefined;
+    }>>;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    transaction?: {
+        from: string;
+        hash: string;
+        to: string | null;
+        value: string;
+        status?: string | undefined;
+        blockNumber?: string | undefined;
+        gasPrice?: string | undefined;
+        gasUsed?: string | undefined;
+    } | undefined;
+    error?: string | undefined;
+}, {
+    success: boolean;
+    transaction?: {
+        from: string;
+        hash: string;
+        to: string | null;
+        value: string;
+        status?: string | undefined;
+        blockNumber?: string | undefined;
+        gasPrice?: string | undefined;
+        gasUsed?: string | undefined;
+    } | undefined;
+    error?: string | undefined;
+}>, {
+    [x: string]: never;
+}>;
+/**
+ * Send Transaction Tool
+ *
+ * Sends a native token transaction to another address.
+ * Requires a private key to be configured in the runtime.
+ *
+ * @tool sendTransaction
+ * @category Blockchain
+ *
+ * @param {string} to - The recipient address
+ * @param {string} amount - The amount to send (in ETH, MATIC, etc.)
+ * @param {string} [chain] - The blockchain network (defaults to mainnet)
+ *
+ * @returns {Promise<{success: boolean, hash?: string, error?: string}>}
+ */
+declare const sendTransactionTool: Tool<z.ZodObject<{
+    to: z.ZodString;
+    amount: z.ZodString;
+    chain: z.ZodDefault<z.ZodEnum<["mainnet", "sepolia", "polygon", "arbitrum", "optimism", "base"]>>;
+}, "strip", z.ZodTypeAny, {
+    chain: "mainnet" | "sepolia" | "polygon" | "arbitrum" | "optimism" | "base";
+    to: string;
+    amount: string;
+}, {
+    to: string;
+    amount: string;
+    chain?: "mainnet" | "sepolia" | "polygon" | "arbitrum" | "optimism" | "base" | undefined;
+}>, z.ZodObject<{
+    success: z.ZodBoolean;
+    hash: z.ZodOptional<z.ZodString>;
+    from: z.ZodOptional<z.ZodString>;
+    to: z.ZodString;
+    amount: z.ZodString;
+    chain: z.ZodString;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    chain: string;
+    to: string;
+    success: boolean;
+    amount: string;
+    from?: string | undefined;
+    hash?: string | undefined;
+    error?: string | undefined;
+}, {
+    chain: string;
+    to: string;
+    success: boolean;
+    amount: string;
+    from?: string | undefined;
+    hash?: string | undefined;
+    error?: string | undefined;
+}>, {
+    [x: string]: never;
+}>;
+/**
+ * Get Block Tool
+ *
+ * Retrieves information about a specific block.
+ *
+ * @tool getBlock
+ * @category Blockchain
+ *
+ * @param {string} [blockNumber] - Block number (defaults to latest)
+ * @param {string} [chain] - The blockchain network (defaults to mainnet)
+ *
+ * @returns {Promise<{success: boolean, block?: object, error?: string}>}
+ */
+declare const getBlockTool: Tool<z.ZodObject<{
+    blockNumber: z.ZodOptional<z.ZodString>;
+    chain: z.ZodDefault<z.ZodEnum<["mainnet", "sepolia", "polygon", "arbitrum", "optimism", "base"]>>;
+}, "strip", z.ZodTypeAny, {
+    chain: "mainnet" | "sepolia" | "polygon" | "arbitrum" | "optimism" | "base";
+    blockNumber?: string | undefined;
+}, {
+    chain?: "mainnet" | "sepolia" | "polygon" | "arbitrum" | "optimism" | "base" | undefined;
+    blockNumber?: string | undefined;
+}>, z.ZodObject<{
+    success: z.ZodBoolean;
+    block: z.ZodOptional<z.ZodObject<{
+        number: z.ZodString;
+        hash: z.ZodString;
+        timestamp: z.ZodString;
+        transactionCount: z.ZodNumber;
+        gasUsed: z.ZodString;
+        gasLimit: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        number: string;
+        hash: string;
+        gasLimit: string;
+        gasUsed: string;
+        timestamp: string;
+        transactionCount: number;
+    }, {
+        number: string;
+        hash: string;
+        gasLimit: string;
+        gasUsed: string;
+        timestamp: string;
+        transactionCount: number;
+    }>>;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    block?: {
+        number: string;
+        hash: string;
+        gasLimit: string;
+        gasUsed: string;
+        timestamp: string;
+        transactionCount: number;
+    } | undefined;
+    error?: string | undefined;
+}, {
+    success: boolean;
+    block?: {
+        number: string;
+        hash: string;
+        gasLimit: string;
+        gasUsed: string;
+        timestamp: string;
+        transactionCount: number;
+    } | undefined;
+    error?: string | undefined;
+}>, {
+    [x: string]: never;
+}>;
+/**
+ * Get Gas Price Tool
+ *
+ * Retrieves current gas price information for a blockchain.
+ *
+ * @tool getGasPrice
+ * @category Blockchain
+ *
+ * @param {string} [chain] - The blockchain network (defaults to mainnet)
+ *
+ * @returns {Promise<{success: boolean, gasPrice?: string, error?: string}>}
+ */
+declare const getGasPriceTool: Tool<z.ZodObject<{
+    chain: z.ZodDefault<z.ZodEnum<["mainnet", "sepolia", "polygon", "arbitrum", "optimism", "base"]>>;
+}, "strip", z.ZodTypeAny, {
+    chain: "mainnet" | "sepolia" | "polygon" | "arbitrum" | "optimism" | "base";
+}, {
+    chain?: "mainnet" | "sepolia" | "polygon" | "arbitrum" | "optimism" | "base" | undefined;
+}>, z.ZodObject<{
+    success: z.ZodBoolean;
+    gasPrice: z.ZodOptional<z.ZodString>;
+    gasPriceWei: z.ZodOptional<z.ZodString>;
+    chain: z.ZodString;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    chain: string;
+    success: boolean;
+    gasPrice?: string | undefined;
+    error?: string | undefined;
+    gasPriceWei?: string | undefined;
+}, {
+    chain: string;
+    success: boolean;
+    gasPrice?: string | undefined;
+    error?: string | undefined;
+    gasPriceWei?: string | undefined;
+}>, {
+    [x: string]: never;
+}>;
+/**
+ * Estimate Gas Tool
+ *
+ * Estimates gas required for a transaction.
+ *
+ * @tool estimateGas
+ * @category Blockchain
+ *
+ * @param {string} to - The recipient address
+ * @param {string} [amount] - The amount to send (defaults to 0)
+ * @param {string} [data] - Transaction data (for contract calls)
+ * @param {string} [chain] - The blockchain network (defaults to mainnet)
+ *
+ * @returns {Promise<{success: boolean, gasEstimate?: string, error?: string}>}
+ */
+declare const estimateGasTool: Tool<z.ZodObject<{
+    to: z.ZodString;
+    amount: z.ZodDefault<z.ZodString>;
+    data: z.ZodOptional<z.ZodString>;
+    chain: z.ZodDefault<z.ZodEnum<["mainnet", "sepolia", "polygon", "arbitrum", "optimism", "base"]>>;
+}, "strip", z.ZodTypeAny, {
+    chain: "mainnet" | "sepolia" | "polygon" | "arbitrum" | "optimism" | "base";
+    to: string;
+    amount: string;
+    data?: string | undefined;
+}, {
+    to: string;
+    chain?: "mainnet" | "sepolia" | "polygon" | "arbitrum" | "optimism" | "base" | undefined;
+    data?: string | undefined;
+    amount?: string | undefined;
+}>, z.ZodObject<{
+    success: z.ZodBoolean;
+    gasEstimate: z.ZodOptional<z.ZodString>;
+    to: z.ZodString;
+    amount: z.ZodString;
+    chain: z.ZodString;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    chain: string;
+    to: string;
+    success: boolean;
+    amount: string;
+    error?: string | undefined;
+    gasEstimate?: string | undefined;
+}, {
+    chain: string;
+    to: string;
+    success: boolean;
+    amount: string;
+    error?: string | undefined;
+    gasEstimate?: string | undefined;
+}>, {
+    [x: string]: never;
+}>;
+/**
+ * Collection of blockchain tools for crypto agents
+ *
+ * These tools provide comprehensive blockchain interaction capabilities including
+ * balance checking, transaction sending, gas estimation, and more.
+ *
+ * @namespace blockchainTools
+ *
+ * @property {Tool} getBalance - Get native token balance for an address
+ * @property {Tool} getTransaction - Get transaction details by hash
+ * @property {Tool} sendTransaction - Send native tokens to another address
+ * @property {Tool} getBlock - Get information about a blockchain block
+ * @property {Tool} getGasPrice - Get current gas price for a blockchain
+ * @property {Tool} estimateGas - Estimate gas required for a transaction
+ */
+declare const blockchainTools: {
+    getBalance: Tool<z.ZodObject<{
+        address: z.ZodString;
+        chain: z.ZodDefault<z.ZodEnum<["mainnet", "sepolia", "polygon", "arbitrum", "optimism", "base"]>>;
+    }, "strip", z.ZodTypeAny, {
+        chain: "mainnet" | "sepolia" | "polygon" | "arbitrum" | "optimism" | "base";
+        address: string;
+    }, {
+        address: string;
+        chain?: "mainnet" | "sepolia" | "polygon" | "arbitrum" | "optimism" | "base" | undefined;
+    }>, z.ZodObject<{
+        success: z.ZodBoolean;
+        balance: z.ZodString;
+        balanceWei: z.ZodString;
+        address: z.ZodString;
+        chain: z.ZodString;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        chain: string;
+        address: string;
+        success: boolean;
+        balance: string;
+        balanceWei: string;
+        error?: string | undefined;
+    }, {
+        chain: string;
+        address: string;
+        success: boolean;
+        balance: string;
+        balanceWei: string;
+        error?: string | undefined;
+    }>, {
+        [x: string]: never;
+    }>;
+    getTransaction: Tool<z.ZodObject<{
+        hash: z.ZodString;
+        chain: z.ZodDefault<z.ZodEnum<["mainnet", "sepolia", "polygon", "arbitrum", "optimism", "base"]>>;
+    }, "strip", z.ZodTypeAny, {
+        chain: "mainnet" | "sepolia" | "polygon" | "arbitrum" | "optimism" | "base";
+        hash: string;
+    }, {
+        hash: string;
+        chain?: "mainnet" | "sepolia" | "polygon" | "arbitrum" | "optimism" | "base" | undefined;
+    }>, z.ZodObject<{
+        success: z.ZodBoolean;
+        transaction: z.ZodOptional<z.ZodObject<{
+            hash: z.ZodString;
+            from: z.ZodString;
+            to: z.ZodNullable<z.ZodString>;
+            value: z.ZodString;
+            gasUsed: z.ZodOptional<z.ZodString>;
+            gasPrice: z.ZodOptional<z.ZodString>;
+            blockNumber: z.ZodOptional<z.ZodString>;
+            status: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            from: string;
+            hash: string;
+            to: string | null;
+            value: string;
+            status?: string | undefined;
+            blockNumber?: string | undefined;
+            gasPrice?: string | undefined;
+            gasUsed?: string | undefined;
+        }, {
+            from: string;
+            hash: string;
+            to: string | null;
+            value: string;
+            status?: string | undefined;
+            blockNumber?: string | undefined;
+            gasPrice?: string | undefined;
+            gasUsed?: string | undefined;
+        }>>;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        success: boolean;
+        transaction?: {
+            from: string;
+            hash: string;
+            to: string | null;
+            value: string;
+            status?: string | undefined;
+            blockNumber?: string | undefined;
+            gasPrice?: string | undefined;
+            gasUsed?: string | undefined;
+        } | undefined;
+        error?: string | undefined;
+    }, {
+        success: boolean;
+        transaction?: {
+            from: string;
+            hash: string;
+            to: string | null;
+            value: string;
+            status?: string | undefined;
+            blockNumber?: string | undefined;
+            gasPrice?: string | undefined;
+            gasUsed?: string | undefined;
+        } | undefined;
+        error?: string | undefined;
+    }>, {
+        [x: string]: never;
+    }>;
+    sendTransaction: Tool<z.ZodObject<{
+        to: z.ZodString;
+        amount: z.ZodString;
+        chain: z.ZodDefault<z.ZodEnum<["mainnet", "sepolia", "polygon", "arbitrum", "optimism", "base"]>>;
+    }, "strip", z.ZodTypeAny, {
+        chain: "mainnet" | "sepolia" | "polygon" | "arbitrum" | "optimism" | "base";
+        to: string;
+        amount: string;
+    }, {
+        to: string;
+        amount: string;
+        chain?: "mainnet" | "sepolia" | "polygon" | "arbitrum" | "optimism" | "base" | undefined;
+    }>, z.ZodObject<{
+        success: z.ZodBoolean;
+        hash: z.ZodOptional<z.ZodString>;
+        from: z.ZodOptional<z.ZodString>;
+        to: z.ZodString;
+        amount: z.ZodString;
+        chain: z.ZodString;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        chain: string;
+        to: string;
+        success: boolean;
+        amount: string;
+        from?: string | undefined;
+        hash?: string | undefined;
+        error?: string | undefined;
+    }, {
+        chain: string;
+        to: string;
+        success: boolean;
+        amount: string;
+        from?: string | undefined;
+        hash?: string | undefined;
+        error?: string | undefined;
+    }>, {
+        [x: string]: never;
+    }>;
+    getBlock: Tool<z.ZodObject<{
+        blockNumber: z.ZodOptional<z.ZodString>;
+        chain: z.ZodDefault<z.ZodEnum<["mainnet", "sepolia", "polygon", "arbitrum", "optimism", "base"]>>;
+    }, "strip", z.ZodTypeAny, {
+        chain: "mainnet" | "sepolia" | "polygon" | "arbitrum" | "optimism" | "base";
+        blockNumber?: string | undefined;
+    }, {
+        chain?: "mainnet" | "sepolia" | "polygon" | "arbitrum" | "optimism" | "base" | undefined;
+        blockNumber?: string | undefined;
+    }>, z.ZodObject<{
+        success: z.ZodBoolean;
+        block: z.ZodOptional<z.ZodObject<{
+            number: z.ZodString;
+            hash: z.ZodString;
+            timestamp: z.ZodString;
+            transactionCount: z.ZodNumber;
+            gasUsed: z.ZodString;
+            gasLimit: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            number: string;
+            hash: string;
+            gasLimit: string;
+            gasUsed: string;
+            timestamp: string;
+            transactionCount: number;
+        }, {
+            number: string;
+            hash: string;
+            gasLimit: string;
+            gasUsed: string;
+            timestamp: string;
+            transactionCount: number;
+        }>>;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        success: boolean;
+        block?: {
+            number: string;
+            hash: string;
+            gasLimit: string;
+            gasUsed: string;
+            timestamp: string;
+            transactionCount: number;
+        } | undefined;
+        error?: string | undefined;
+    }, {
+        success: boolean;
+        block?: {
+            number: string;
+            hash: string;
+            gasLimit: string;
+            gasUsed: string;
+            timestamp: string;
+            transactionCount: number;
+        } | undefined;
+        error?: string | undefined;
+    }>, {
+        [x: string]: never;
+    }>;
+    getGasPrice: Tool<z.ZodObject<{
+        chain: z.ZodDefault<z.ZodEnum<["mainnet", "sepolia", "polygon", "arbitrum", "optimism", "base"]>>;
+    }, "strip", z.ZodTypeAny, {
+        chain: "mainnet" | "sepolia" | "polygon" | "arbitrum" | "optimism" | "base";
+    }, {
+        chain?: "mainnet" | "sepolia" | "polygon" | "arbitrum" | "optimism" | "base" | undefined;
+    }>, z.ZodObject<{
+        success: z.ZodBoolean;
+        gasPrice: z.ZodOptional<z.ZodString>;
+        gasPriceWei: z.ZodOptional<z.ZodString>;
+        chain: z.ZodString;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        chain: string;
+        success: boolean;
+        gasPrice?: string | undefined;
+        error?: string | undefined;
+        gasPriceWei?: string | undefined;
+    }, {
+        chain: string;
+        success: boolean;
+        gasPrice?: string | undefined;
+        error?: string | undefined;
+        gasPriceWei?: string | undefined;
+    }>, {
+        [x: string]: never;
+    }>;
+    estimateGas: Tool<z.ZodObject<{
+        to: z.ZodString;
+        amount: z.ZodDefault<z.ZodString>;
+        data: z.ZodOptional<z.ZodString>;
+        chain: z.ZodDefault<z.ZodEnum<["mainnet", "sepolia", "polygon", "arbitrum", "optimism", "base"]>>;
+    }, "strip", z.ZodTypeAny, {
+        chain: "mainnet" | "sepolia" | "polygon" | "arbitrum" | "optimism" | "base";
+        to: string;
+        amount: string;
+        data?: string | undefined;
+    }, {
+        to: string;
+        chain?: "mainnet" | "sepolia" | "polygon" | "arbitrum" | "optimism" | "base" | undefined;
+        data?: string | undefined;
+        amount?: string | undefined;
+    }>, z.ZodObject<{
+        success: z.ZodBoolean;
+        gasEstimate: z.ZodOptional<z.ZodString>;
+        to: z.ZodString;
+        amount: z.ZodString;
+        chain: z.ZodString;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        chain: string;
+        to: string;
+        success: boolean;
+        amount: string;
+        error?: string | undefined;
+        gasEstimate?: string | undefined;
+    }, {
+        chain: string;
+        to: string;
+        success: boolean;
+        amount: string;
+        error?: string | undefined;
+        gasEstimate?: string | undefined;
+    }>, {
+        [x: string]: never;
+    }>;
+};
+
+/**
+ * Send Reaction Tool
+ *
+ * Sends an emoji reaction to a specific message to indicate the message has been seen.
+ * This is used to acknowledge receipt of messages before responding.
+ *
+ * @tool sendReaction
+ * @category Communication
+ *
+ * @param {string} emoji - The emoji to send as a reaction (defaults to 👀)
+ * @param {string} [referenceMessageId] - The message ID to react to (uses current message if not provided)
+ *
+ * @returns {Promise<{success: boolean, emoji: string, error?: string}>}
+ */
+declare const sendReactionTool: Tool<z.ZodObject<{
+    emoji: z.ZodDefault<z.ZodString>;
+    referenceMessageId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    emoji: string;
+    referenceMessageId?: string | undefined;
+}, {
+    referenceMessageId?: string | undefined;
+    emoji?: string | undefined;
+}>, z.ZodObject<{
+    success: z.ZodBoolean;
+    emoji: z.ZodString;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    emoji: string;
+    success: boolean;
+    error?: string | undefined;
+}, {
+    emoji: string;
+    success: boolean;
+    error?: string | undefined;
+}>, {
+    [x: string]: never;
+}>;
+/**
+ * Send Message Tool
+ *
+ * Sends a message to an XMTP conversation or creates a new conversation.
+ *
+ * @tool sendMessage
+ * @category Communication
+ *
+ * @param {string} content - The message content to send
+ * @param {string} [recipientAddress] - Recipient address for new conversations
+ * @param {string} [conversationId] - Existing conversation ID to send to
+ *
+ * @returns {Promise<{success: boolean, messageId?: string, conversationId?: string, error?: string}>}
+ */
+declare const sendMessageTool: Tool<z.ZodEffects<z.ZodObject<{
+    content: z.ZodString;
+    recipientAddress: z.ZodOptional<z.ZodString>;
+    conversationId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    conversationId?: string | undefined;
+    recipientAddress?: string | undefined;
+}, {
+    content: string;
+    conversationId?: string | undefined;
+    recipientAddress?: string | undefined;
+}>, {
+    content: string;
+    conversationId?: string | undefined;
+    recipientAddress?: string | undefined;
+}, {
+    content: string;
+    conversationId?: string | undefined;
+    recipientAddress?: string | undefined;
+}>, z.ZodObject<{
+    success: z.ZodBoolean;
+    messageId: z.ZodOptional<z.ZodString>;
+    conversationId: z.ZodOptional<z.ZodString>;
+    content: z.ZodString;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    success: boolean;
+    conversationId?: string | undefined;
+    error?: string | undefined;
+    messageId?: string | undefined;
+}, {
+    content: string;
+    success: boolean;
+    conversationId?: string | undefined;
+    error?: string | undefined;
+    messageId?: string | undefined;
+}>, {
+    [x: string]: never;
+}>;
+/**
+ * Send Reply Tool
+ *
+ * Sends a reply to a specific message in an XMTP conversation.
+ *
+ * @tool sendReply
+ * @category Communication
+ *
+ * @param {string} content - The reply content to send
+ * @param {string} [replyToMessageId] - Message ID to reply to (uses current message if not provided)
+ *
+ * @returns {Promise<{success: boolean, messageId?: string, replyToMessageId?: string, error?: string}>}
+ */
+declare const sendReplyTool: Tool<z.ZodObject<{
+    content: z.ZodString;
+    replyToMessageId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    replyToMessageId?: string | undefined;
+}, {
+    content: string;
+    replyToMessageId?: string | undefined;
+}>, z.ZodObject<{
+    success: z.ZodBoolean;
+    messageId: z.ZodOptional<z.ZodString>;
+    replyToMessageId: z.ZodOptional<z.ZodString>;
+    content: z.ZodString;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    success: boolean;
+    error?: string | undefined;
+    messageId?: string | undefined;
+    replyToMessageId?: string | undefined;
+}, {
+    content: string;
+    success: boolean;
+    error?: string | undefined;
+    messageId?: string | undefined;
+    replyToMessageId?: string | undefined;
+}>, {
+    [x: string]: never;
+}>;
+/**
+ * Get Message Tool
+ *
+ * Retrieves a specific message by ID from the XMTP service.
+ *
+ * @tool getMessage
+ * @category Communication
+ *
+ * @param {string} messageId - The message ID to retrieve
+ *
+ * @returns {Promise<{success: boolean, message?: object, error?: string}>}
+ */
+declare const getMessageTool: Tool<z.ZodObject<{
+    messageId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    messageId: string;
+}, {
+    messageId: string;
+}>, z.ZodObject<{
+    success: z.ZodBoolean;
+    message: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        conversationId: z.ZodString;
+        content: z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+        senderInboxId: z.ZodString;
+        sentAt: z.ZodString;
+        contentType: z.ZodOptional<z.ZodObject<{
+            typeId: z.ZodString;
+            authorityId: z.ZodOptional<z.ZodString>;
+            versionMajor: z.ZodOptional<z.ZodNumber>;
+            versionMinor: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            typeId: string;
+            authorityId?: string | undefined;
+            versionMajor?: number | undefined;
+            versionMinor?: number | undefined;
+        }, {
+            typeId: string;
+            authorityId?: string | undefined;
+            versionMajor?: number | undefined;
+            versionMinor?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        conversationId: string;
+        content: string | Record<string, unknown>;
+        id: string;
+        senderInboxId: string;
+        sentAt: string;
+        contentType?: {
+            typeId: string;
+            authorityId?: string | undefined;
+            versionMajor?: number | undefined;
+            versionMinor?: number | undefined;
+        } | undefined;
+    }, {
+        conversationId: string;
+        content: string | Record<string, unknown>;
+        id: string;
+        senderInboxId: string;
+        sentAt: string;
+        contentType?: {
+            typeId: string;
+            authorityId?: string | undefined;
+            versionMajor?: number | undefined;
+            versionMinor?: number | undefined;
+        } | undefined;
+    }>>;
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    success: boolean;
+    message?: {
+        conversationId: string;
+        content: string | Record<string, unknown>;
+        id: string;
+        senderInboxId: string;
+        sentAt: string;
+        contentType?: {
+            typeId: string;
+            authorityId?: string | undefined;
+            versionMajor?: number | undefined;
+            versionMinor?: number | undefined;
+        } | undefined;
+    } | undefined;
+    error?: string | undefined;
+}, {
+    success: boolean;
+    message?: {
+        conversationId: string;
+        content: string | Record<string, unknown>;
+        id: string;
+        senderInboxId: string;
+        sentAt: string;
+        contentType?: {
+            typeId: string;
+            authorityId?: string | undefined;
+            versionMajor?: number | undefined;
+            versionMinor?: number | undefined;
+        } | undefined;
+    } | undefined;
+    error?: string | undefined;
+}>, {
+    [x: string]: never;
+}>;
+/**
+ * Collection of XMTP communication tools for crypto agents
+ *
+ * These tools provide comprehensive messaging capabilities including sending messages,
+ * replies, reactions, and retrieving message information.
+ *
+ * @namespace xmtpTools
+ *
+ * @property {Tool} sendMessage - Send a message to an XMTP conversation
+ * @property {Tool} sendReply - Send a reply to a specific message
+ * @property {Tool} sendReaction - Send an emoji reaction to a message
+ * @property {Tool} getMessage - Get a specific message by ID
+ */
+declare const xmtpTools: {
+    sendMessage: Tool<z.ZodEffects<z.ZodObject<{
+        content: z.ZodString;
+        recipientAddress: z.ZodOptional<z.ZodString>;
+        conversationId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        content: string;
+        conversationId?: string | undefined;
+        recipientAddress?: string | undefined;
+    }, {
+        content: string;
+        conversationId?: string | undefined;
+        recipientAddress?: string | undefined;
+    }>, {
+        content: string;
+        conversationId?: string | undefined;
+        recipientAddress?: string | undefined;
+    }, {
+        content: string;
+        conversationId?: string | undefined;
+        recipientAddress?: string | undefined;
+    }>, z.ZodObject<{
+        success: z.ZodBoolean;
+        messageId: z.ZodOptional<z.ZodString>;
+        conversationId: z.ZodOptional<z.ZodString>;
+        content: z.ZodString;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        content: string;
+        success: boolean;
+        conversationId?: string | undefined;
+        error?: string | undefined;
+        messageId?: string | undefined;
+    }, {
+        content: string;
+        success: boolean;
+        conversationId?: string | undefined;
+        error?: string | undefined;
+        messageId?: string | undefined;
+    }>, {
+        [x: string]: never;
+    }>;
+    sendReply: Tool<z.ZodObject<{
+        content: z.ZodString;
+        replyToMessageId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        content: string;
+        replyToMessageId?: string | undefined;
+    }, {
+        content: string;
+        replyToMessageId?: string | undefined;
+    }>, z.ZodObject<{
+        success: z.ZodBoolean;
+        messageId: z.ZodOptional<z.ZodString>;
+        replyToMessageId: z.ZodOptional<z.ZodString>;
+        content: z.ZodString;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        content: string;
+        success: boolean;
+        error?: string | undefined;
+        messageId?: string | undefined;
+        replyToMessageId?: string | undefined;
+    }, {
+        content: string;
+        success: boolean;
+        error?: string | undefined;
+        messageId?: string | undefined;
+        replyToMessageId?: string | undefined;
+    }>, {
+        [x: string]: never;
+    }>;
+    sendReaction: Tool<z.ZodObject<{
+        emoji: z.ZodDefault<z.ZodString>;
+        referenceMessageId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        emoji: string;
+        referenceMessageId?: string | undefined;
+    }, {
+        referenceMessageId?: string | undefined;
+        emoji?: string | undefined;
+    }>, z.ZodObject<{
+        success: z.ZodBoolean;
+        emoji: z.ZodString;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        emoji: string;
+        success: boolean;
+        error?: string | undefined;
+    }, {
+        emoji: string;
+        success: boolean;
+        error?: string | undefined;
+    }>, {
+        [x: string]: never;
+    }>;
+    getMessage: Tool<z.ZodObject<{
+        messageId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        messageId: string;
+    }, {
+        messageId: string;
+    }>, z.ZodObject<{
+        success: z.ZodBoolean;
+        message: z.ZodOptional<z.ZodObject<{
+            id: z.ZodString;
+            conversationId: z.ZodString;
+            content: z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+            senderInboxId: z.ZodString;
+            sentAt: z.ZodString;
+            contentType: z.ZodOptional<z.ZodObject<{
+                typeId: z.ZodString;
+                authorityId: z.ZodOptional<z.ZodString>;
+                versionMajor: z.ZodOptional<z.ZodNumber>;
+                versionMinor: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                typeId: string;
+                authorityId?: string | undefined;
+                versionMajor?: number | undefined;
+                versionMinor?: number | undefined;
+            }, {
+                typeId: string;
+                authorityId?: string | undefined;
+                versionMajor?: number | undefined;
+                versionMinor?: number | undefined;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            conversationId: string;
+            content: string | Record<string, unknown>;
+            id: string;
+            senderInboxId: string;
+            sentAt: string;
+            contentType?: {
+                typeId: string;
+                authorityId?: string | undefined;
+                versionMajor?: number | undefined;
+                versionMinor?: number | undefined;
+            } | undefined;
+        }, {
+            conversationId: string;
+            content: string | Record<string, unknown>;
+            id: string;
+            senderInboxId: string;
+            sentAt: string;
+            contentType?: {
+                typeId: string;
+                authorityId?: string | undefined;
+                versionMajor?: number | undefined;
+                versionMinor?: number | undefined;
+            } | undefined;
+        }>>;
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        success: boolean;
+        message?: {
+            conversationId: string;
+            content: string | Record<string, unknown>;
+            id: string;
+            senderInboxId: string;
+            sentAt: string;
+            contentType?: {
+                typeId: string;
+                authorityId?: string | undefined;
+                versionMajor?: number | undefined;
+                versionMinor?: number | undefined;
+            } | undefined;
+        } | undefined;
+        error?: string | undefined;
+    }, {
+        success: boolean;
+        message?: {
+            conversationId: string;
+            content: string | Record<string, unknown>;
+            id: string;
+            senderInboxId: string;
+            sentAt: string;
+            contentType?: {
+                typeId: string;
+                authorityId?: string | undefined;
+                versionMajor?: number | undefined;
+                versionMinor?: number | undefined;
+            } | undefined;
+        } | undefined;
+        error?: string | undefined;
+    }>, {
+        [x: string]: never;
+    }>;
+};
+
+export { type AgentRuntime as A, type BaseRuntime as B, type Tool as T, type XmtpCredentials as X, type ToolConfig as a, blockchainTools as b, createTool as c, getBlockTool as d, estimateGasTool as e, getGasPriceTool as f, getBalanceTool as g, getTransactionTool as h, type BlockchainRuntimeExtension as i, getMessageTool as j, sendMessageTool as k, sendReactionTool as l, sendReplyTool as m, sendTransactionTool as s, toolFactory as t, xmtpTools as x };