@exagent/sdk 0.1.20 → 0.2.0

package/dist/index.d.ts

@@ -1,2099 +1,489 @@
-import * as viem from 'viem';
-import { Address, Hash, Chain, Account, Hex, WalletClient } from 'viem';
-import * as viem_chains from 'viem/chains';
+import { z } from 'zod';
 
-/**
- * ERC-8004 Global Agent Identifier
- * Format: eip155:{chainId}:{registryAddress}:{agentId}
- *
- * This creates a universally unique identifier for any agent across
- * all EVM chains, enabling cross-protocol agent discovery.
- *
- * @example
- * ```
- * // Base mainnet agent #42
- * "eip155:8453:0xABC...DEF:42"
- *
- * // Another Base mainnet agent
- * "eip155:8453:0x123...789:7"
- * ```
- */
-type GlobalAgentId = `eip155:${number}:${Address}:${number}`;
-/**
- * Build an ERC-8004 compliant global agent identifier
- *
- * @param chainId - EVM chain ID (8453 for Base)
- * @param registryAddress - ExagentRegistry contract address
- * @param agentId - On-chain agent ID (from ExagentRegistry)
- * @returns Global agent identifier string
- *
- * @example
- * ```typescript
- * import { buildGlobalAgentId } from '@exagent/sdk';
- *
- * const globalId = buildGlobalAgentId(8453, '0xABC...DEF', 42);
- * // => "eip155:8453:0xABC...DEF:42"
- * ```
- */
-declare function buildGlobalAgentId(chainId: number, registryAddress: Address, agentId: number | bigint): GlobalAgentId;
-/**
- * Parse an ERC-8004 global agent identifier into its components
- *
- * @param globalId - The global agent identifier string
- * @returns Parsed components: chainId, registryAddress, agentId
- * @throws Error if the format is invalid
- */
-declare function parseGlobalAgentId(globalId: string): {
-    chainId: number;
-    registryAddress: Address;
-    agentId: number;
-};
-/**
- * Agent profile as stored on-chain
- */
 interface AgentProfile {
-    agentId: bigint;
-    owner: Address;
+    id: string;
+    userId: string;
     name: string;
-    metadataURI: string;
-    registrationTime: bigint;
-    verified: boolean;
-    linkedWalletCount: bigint;
+    description?: string;
+    status: AgentStatus;
+    config: AgentConfig;
+    createdAt: string;
+    updatedAt: string;
 }
-/**
- * Agent metadata stored on IPFS
- */
-interface AgentMetadata {
-    name: string;
-    description: string;
-    capabilities: string[];
+type AgentStatus = 'online' | 'idle' | 'trading' | 'error' | 'offline';
+interface AgentConfig {
+    llm: LLMConfig;
+    strategy: StrategyConfig;
+    trading: TradingConfig;
+    relay: RelayConfig;
+    venues?: VenueConfig;
+}
+interface LLMConfig {
+    provider: LLMProvider;
     model?: string;
-    framework?: string;
-    avatar?: string;
-    website?: string;
-    social?: {
-        twitter?: string;
-        github?: string;
-    };
+    apiKey?: string;
+    endpoint?: string;
+    temperature?: number;
+    maxTokens?: number;
 }
-/**
- * Trade intent for broadcasting
- */
-interface TradeIntent {
-    action: 'BUY' | 'SELL';
-    tokenIn: Address;
-    tokenOut: Address;
-    amountIn: bigint;
-    minAmountOut?: bigint;
-    maxSlippageBps?: number;
-    deadline?: number;
-    /** LLM config hash (bytes32) for epoch attribution — passed to on-chain router */
-    configHash?: `0x${string}`;
+type LLMProvider = 'openai' | 'anthropic' | 'google' | 'deepseek' | 'mistral' | 'groq' | 'together' | 'ollama';
+interface StrategyConfig {
+    file?: string;
+    template?: string;
 }
-/**
- * M2M service request
- */
-interface ServiceRequest {
-    serviceType: string;
-    providerId?: bigint;
-    maxPriceAX: bigint;
-    payload: Record<string, unknown>;
-    deadline?: number;
+interface TradingConfig {
+    mode: 'live' | 'paper';
+    timeHorizon: 'intraday' | 'swing' | 'position';
+    maxPositionSizeBps: number;
+    maxDailyLossBps: number;
+    maxConcurrentPositions: number;
+    tradingIntervalMs: number;
+    maxSlippageBps: number;
+    minTradeValueUSD: number;
+    initialCapitalUSD?: number;
 }
-/**
- * Performance metrics snapshot
- */
-interface PerformanceSnapshot {
-    agentId: bigint;
-    timestamp: bigint;
-    pnlBps: number;
-    tradeCount: number;
-    volumeUSD: bigint;
-    sharpeRatio?: number;
-    sortinoRatio?: number;
-    maxDrawdownBps?: number;
+interface RelayConfig {
+    url: string;
+    heartbeatIntervalMs?: number;
+    reconnectMaxAttempts?: number;
 }
-/**
- * DEX route quote from 0x API
- */
-interface RouteQuote {
-    tokenIn: Address;
-    tokenOut: Address;
-    amountIn: string;
-    amountOut: string;
-    minAmountOut: string;
-    priceImpactBps: number;
-    route: RouteStep[];
-    transaction: {
-        to: Address;
-        data: `0x${string}`;
-        value: string;
+interface VenueConfig {
+    hyperliquid?: {
+        enabled: boolean;
+        maxLeverage?: number;
+        maxNotionalUSD?: number;
     };
-    gasEstimate: string;
-    validUntil: number;
-    permit2?: {
-        eip712: unknown;
+    polymarket?: {
+        enabled: boolean;
+        maxNotionalUSD?: number;
+        maxExposureUSD?: number;
     };
-    issues?: {
-        allowance?: {
-            spender: Address;
-            actual: string;
-            expected: string;
-        };
+    spot?: {
+        enabled: boolean;
+        chains?: string[];
     };
-    mock?: boolean;
 }
-/**
- * Route step through a DEX
- */
-interface RouteStep {
-    dex: string;
-    pool: string;
-    share: number;
+interface TradeSignal {
+    venue: string;
+    chain?: string;
+    symbol: string;
+    side: 'long' | 'short' | 'buy' | 'sell';
+    size: number;
+    price: number;
+    fee: number;
+    venueFillId: string;
+    venueTimestamp: string;
+    leverage?: number;
+    orderType?: string;
+    confidence?: number;
+    reasoning?: string;
 }
-/**
- * Price quote (no transaction data)
- */
-interface PriceQuote {
-    tokenIn: Address;
-    tokenOut: Address;
-    amountIn: string;
-    amountOut: string;
-    priceImpactBps: number;
-    mock?: boolean;
+interface PerpTradeSignal {
+    action: 'open_long' | 'open_short' | 'close_long' | 'close_short' | 'hold';
+    instrument: string;
+    size: number;
+    price: number;
+    leverage: number;
+    orderType: 'limit' | 'market';
+    reduceOnly: boolean;
+    confidence: number;
+    reasoning?: string;
 }
-/**
- * Router trade response - transaction routed through ExagentRouter
- */
-interface RouterTradeResponse {
-    agentId: number;
-    tokenIn: Address;
-    tokenOut: Address;
-    amountIn: string;
-    amountOut: string;
-    minAmountOut: string;
-    priceImpactBps: number;
-    route: RouteStep[];
-    transaction: {
-        to: Address;
-        data: `0x${string}`;
-        value: string;
-    };
-    approvals: Array<{
-        token: Address;
-        spender: Address;
-        amount: string;
-    }>;
-    gasEstimate: string;
-    validUntil: number;
-    attribution: {
-        router: Address;
-        aggregator: Address;
-        agentId: number;
+interface PredictionTradeSignal {
+    action: 'buy_yes' | 'buy_no' | 'sell_yes' | 'sell_no' | 'hold';
+    marketConditionId: string;
+    marketQuestion: string;
+    outcomeIndex: number;
+    amount: number;
+    limitPrice: number;
+    confidence: number;
+    reasoning?: string;
+}
+interface LLMMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+}
+interface LLMResponse {
+    content: string;
+    tokens?: {
+        input: number;
+        output: number;
     };
-    mock?: boolean;
-    /** Present when API's pre-flight simulation failed (for sells) */
-    simulationSkipped?: boolean;
-    /** Warning message when simulation failed */
-    simulationWarning?: string;
 }
-/**
- * Trade execution result
- */
-interface TradeResult {
-    hash: Hash;
-    agentId: bigint;
-    tokenIn: Address;
-    tokenOut: Address;
-    amountIn: string;
-    expectedAmountOut: string;
+interface LLMAdapter {
+    chat(messages: LLMMessage[]): Promise<LLMResponse>;
+    getMetadata(): LLMMetadata;
 }
-/**
- * Vault configuration for creating a new vault
- */
-interface VaultConfig {
-    agentId: bigint;
-    asset: Address;
-    name: string;
-    symbol: string;
-    feeRecipient: Address;
-    performanceFeeBps?: number;
-    managementFeeBps?: number;
+interface LLMMetadata {
+    provider: string;
+    model: string;
+    maxTokens?: number;
+}
+interface StrategyContext {
+    llm: LLMAdapter;
+    market: MarketData;
+    position: PositionSummary;
+    store: StrategyStore;
+    config: TradingConfig;
+    log: (message: string) => void;
 }
-/**
- * Vault summary for listing
- */
-interface VaultSummary {
-    address: Address;
+type StrategyFunction = (context: StrategyContext) => Promise<TradeSignal[]>;
+interface StrategyStore {
+    get<T>(key: string): T | undefined;
+    set<T>(key: string, value: T): void;
+    delete(key: string): void;
+    keys(): string[];
+}
+interface StrategyTemplate {
+    id: string;
     name: string;
-    symbol: string;
-    asset: Address;
-    agentId: bigint;
-    totalAssets: bigint;
-    sharePrice: bigint;
-    performanceFeeBps: number;
-    managementFeeBps: number;
-    depositorCount: number;
-    totalPnlBps: number;
-    isAcceptingDeposits: boolean;
+    description: string;
+    category: 'momentum' | 'value' | 'arbitrage' | 'market_making' | 'custom';
+    venues: string[];
+    riskLevel: 'conservative' | 'moderate' | 'aggressive';
+    code: string;
+    systemPrompt: string;
 }
-/**
- * User's vault position for portfolio display
- */
-interface UserVaultPosition {
-    vault: Address;
-    vaultName: string;
-    shares: bigint;
-    assetsValue: bigint;
-    entryPrice: bigint;
-    currentPrice: bigint;
-    pnlBps: number;
-    pnlUsd: bigint;
-    pendingWithdrawals: bigint;
+interface MarketData {
+    getPrice(symbol: string): number | undefined;
+    getPrices(): Record<string, number>;
+    getOHLCV(symbol: string, timeframe: string): OHLCV[];
 }
-/**
- * Vault deposit/withdrawal history entry
- */
-interface VaultActivityEntry {
-    type: 'deposit' | 'withdraw' | 'request_withdrawal' | 'claim_withdrawal' | 'emergency_withdraw';
-    user: Address;
-    vault: Address;
-    shares: bigint;
-    assets: bigint;
-    timestamp: bigint;
-    txHash: Hash;
+interface OHLCV {
+    timestamp: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
 }
-/**
- * Vault trade executed by agent
- */
-interface VaultTradeEntry {
-    agentId: bigint;
-    vault: Address;
-    tokenIn: Address;
-    tokenOut: Address;
-    amountIn: bigint;
-    amountOut: bigint;
-    aggregator: Address;
-    timestamp: bigint;
-    txHash: Hash;
+interface TrackedPosition {
+    token: string;
+    quantity: number;
+    costBasisPerUnit: number;
+    entryTimestamp: number;
+    venue?: string;
+    chain?: string;
 }
-
-/**
- * ABI for ExagentRegistry contract
- */
-declare const EXAGENT_REGISTRY_ABI: readonly [{
-    readonly type: "function";
-    readonly name: "registerAgent";
-    readonly inputs: readonly [{
-        readonly name: "name";
-        readonly type: "string";
-    }, {
-        readonly name: "metadataURI";
-        readonly type: "string";
-    }, {
-        readonly name: "riskUniverse";
-        readonly type: "uint8";
-    }, {
-        readonly name: "maxPositionSizeBps";
-        readonly type: "uint256";
-    }, {
-        readonly name: "maxDailyLossBps";
-        readonly type: "uint256";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "isNameAvailable";
-    readonly inputs: readonly [{
-        readonly name: "name";
-        readonly type: "string";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "available";
-        readonly type: "bool";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "getAgentByName";
-    readonly inputs: readonly [{
-        readonly name: "name";
-        readonly type: "string";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "linkWallet";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-    }, {
-        readonly name: "wallet";
-        readonly type: "address";
-    }, {
-        readonly name: "signature";
-        readonly type: "bytes";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "linkOwnWallet";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "unlinkWallet";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-    }, {
-        readonly name: "wallet";
-        readonly type: "address";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "updateMetadata";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-    }, {
-        readonly name: "newURI";
-        readonly type: "string";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "agents";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "owner";
-        readonly type: "address";
-    }, {
-        readonly name: "name";
-        readonly type: "string";
-    }, {
-        readonly name: "metadataURI";
-        readonly type: "string";
-    }, {
-        readonly name: "registrationTime";
-        readonly type: "uint256";
-    }, {
-        readonly name: "verified";
-        readonly type: "bool";
-    }, {
-        readonly name: "linkedWalletCount";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "getLinkedWallets";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "address[]";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "getAgentForWallet";
-    readonly inputs: readonly [{
-        readonly name: "wallet";
-        readonly type: "address";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "walletToAgent";
-    readonly inputs: readonly [{
-        readonly name: "wallet";
-        readonly type: "address";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "nonces";
-    readonly inputs: readonly [{
-        readonly name: "wallet";
-        readonly type: "address";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "ownerOf";
-    readonly inputs: readonly [{
-        readonly name: "tokenId";
-        readonly type: "uint256";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "address";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "balanceOf";
-    readonly inputs: readonly [{
-        readonly name: "owner";
-        readonly type: "address";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "event";
-    readonly name: "AgentRegistered";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-        readonly indexed: true;
-    }, {
-        readonly name: "owner";
-        readonly type: "address";
-        readonly indexed: true;
-    }, {
-        readonly name: "name";
-        readonly type: "string";
-        readonly indexed: false;
-    }, {
-        readonly name: "metadataURI";
-        readonly type: "string";
-        readonly indexed: false;
-    }];
-}, {
-    readonly type: "event";
-    readonly name: "WalletLinked";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-        readonly indexed: true;
-    }, {
-        readonly name: "wallet";
-        readonly type: "address";
-        readonly indexed: true;
-    }];
-}, {
-    readonly type: "event";
-    readonly name: "WalletUnlinked";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-        readonly indexed: true;
-    }, {
-        readonly name: "wallet";
-        readonly type: "address";
-        readonly indexed: true;
-    }];
-}, {
-    readonly type: "function";
-    readonly name: "ownerToAgentId";
-    readonly inputs: readonly [{
-        readonly name: "owner";
-        readonly type: "address";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "getAgentByOwner";
-    readonly inputs: readonly [{
-        readonly name: "wallet";
-        readonly type: "address";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "canWalletRegister";
-    readonly inputs: readonly [{
-        readonly name: "wallet";
-        readonly type: "address";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "canRegister";
-        readonly type: "bool";
-    }, {
-        readonly name: "existingAgentId";
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "setConfig";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-    }, {
-        readonly name: "configHash";
-        readonly type: "bytes32";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "getConfigHash";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-    }];
-    readonly outputs: readonly [{
-        readonly name: "";
-        readonly type: "bytes32";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "retireAgent";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-    }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "function";
-    readonly name: "retired";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-    }];
-    readonly outputs: readonly [{
-        readonly type: "bool";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "isRetired";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-    }];
-    readonly outputs: readonly [{
-        readonly type: "bool";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "isTradeAllowed";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-    }, {
-        readonly name: "token";
-        readonly type: "address";
-    }, {
-        readonly name: "aggregator";
-        readonly type: "address";
-    }];
-    readonly outputs: readonly [{
-        readonly type: "bool";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "getRiskUniverse";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-    }];
-    readonly outputs: readonly [{
-        readonly type: "uint8";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "tradeCount";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-    }];
-    readonly outputs: readonly [{
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "event";
-    readonly name: "AgentRetired";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-        readonly indexed: true;
-    }];
-}, {
-    readonly type: "event";
-    readonly name: "ConfigUpdated";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-        readonly indexed: true;
-    }, {
-        readonly name: "oldConfigHash";
-        readonly type: "bytes32";
-        readonly indexed: false;
-    }, {
-        readonly name: "newConfigHash";
-        readonly type: "bytes32";
-        readonly indexed: false;
-    }, {
-        readonly name: "epochId";
-        readonly type: "uint256";
-        readonly indexed: false;
-    }, {
-        readonly name: "blockNumber";
-        readonly type: "uint256";
-        readonly indexed: false;
-    }];
-}, {
-    readonly type: "error";
-    readonly name: "AgentNotOwner";
-    readonly inputs: readonly [];
-}, {
-    readonly type: "error";
-    readonly name: "WalletAlreadyLinked";
-    readonly inputs: readonly [];
-}, {
-    readonly type: "error";
-    readonly name: "WalletNotLinked";
-    readonly inputs: readonly [];
-}, {
-    readonly type: "error";
-    readonly name: "InvalidSignature";
-    readonly inputs: readonly [];
-}, {
-    readonly type: "error";
-    readonly name: "TransferDisabled";
-    readonly inputs: readonly [];
-}, {
-    readonly type: "error";
-    readonly name: "InvalidMetadataURI";
-    readonly inputs: readonly [];
-}, {
-    readonly type: "error";
-    readonly name: "AgentDoesNotExist";
-    readonly inputs: readonly [];
-}, {
-    readonly type: "error";
-    readonly name: "NameAlreadyTaken";
-    readonly inputs: readonly [];
-}, {
-    readonly type: "error";
-    readonly name: "InvalidName";
-    readonly inputs: readonly [];
-}, {
-    readonly type: "error";
-    readonly name: "OwnerAlreadyHasAgent";
-    readonly inputs: readonly [{
-        readonly name: "existingAgentId";
-        readonly type: "uint256";
-    }];
-}, {
-    readonly type: "error";
-    readonly name: "InvalidRiskUniverse";
-    readonly inputs: readonly [];
-}, {
-    readonly type: "error";
-    readonly name: "InvalidTradingConfig";
-    readonly inputs: readonly [];
-}, {
-    readonly type: "error";
-    readonly name: "NotAuthorizedCaller";
-    readonly inputs: readonly [];
-}, {
-    readonly type: "error";
-    readonly name: "MetadataValueTooLarge";
-    readonly inputs: readonly [];
-}, {
-    readonly type: "error";
-    readonly name: "AgentIsRetired";
-    readonly inputs: readonly [];
-}, {
-    readonly type: "error";
-    readonly name: "InvalidRiskUniverseForWhitelist";
-    readonly inputs: readonly [];
-}];
-/**
- * Wrapper for ExagentRegistry contract interactions
- */
-declare class ExagentRegistry {
-    readonly address: Address;
-    private readonly publicClient;
-    private readonly walletClient?;
-    private readonly chain;
-    private readonly account?;
-    constructor(address: Address, publicClient: any, walletClient: any | undefined, chain: Chain, account?: Account);
-    /**
-     * Register a new agent
-     * @param name Unique agent name (3-32 chars, alphanumeric + spaces/hyphens/underscores)
-     * @param metadataURI IPFS URI for agent metadata
-     * @param riskUniverse Risk tier: 0=Core, 1=Established, 2=Derivatives, 3=Emerging, 4=Frontier
-     * @param maxPositionSizeBps Maximum position size in basis points (1-10000)
-     * @param maxDailyLossBps Maximum daily loss in basis points (1-10000)
-     * @returns Transaction hash
-     */
-    register(name: string, metadataURI: string, riskUniverse?: number, maxPositionSizeBps?: bigint, maxDailyLossBps?: bigint): Promise<Hash>;
-    /**
-     * Check if a name is available for registration
-     * @param name The name to check
-     * @returns True if the name can be used
-     */
-    isNameAvailable(name: string): Promise<boolean>;
-    /**
-     * Get the agent ID that owns a specific name
-     * @param name The name to look up
-     * @returns Agent ID (0 if not taken)
-     */
-    getAgentByName(name: string): Promise<bigint>;
-    /**
-     * Link the wallet used by the agent to their agent ID
-     * @param agentId The agent's ID
-     * @returns Transaction hash
-     */
-    linkOwnWallet(agentId: bigint): Promise<Hash>;
-    /**
-     * Link an external wallet with signature proof
-     * @param agentId The agent's ID
-     * @param wallet The wallet to link
-     * @param signature Signature from the wallet proving ownership
-     * @returns Transaction hash
-     */
-    linkWallet(agentId: bigint, wallet: Address, signature: `0x${string}`): Promise<Hash>;
-    /**
-     * Unlink a wallet from an agent
-     * @param agentId The agent's ID
-     * @param wallet The wallet to unlink
-     * @returns Transaction hash
-     */
-    unlinkWallet(agentId: bigint, wallet: Address): Promise<Hash>;
-    /**
-     * Update agent metadata
-     * @param agentId The agent's ID
-     * @param newURI New IPFS URI for metadata
-     * @returns Transaction hash
-     */
-    updateMetadata(agentId: bigint, newURI: string): Promise<Hash>;
-    /**
-     * Get agent profile by ID
-     * @param agentId The agent's ID
-     * @returns Agent profile data
-     */
-    getAgent(agentId: bigint): Promise<AgentProfile>;
-    /**
-     * Get all linked wallets for an agent
-     * @param agentId The agent's ID
-     * @returns Array of linked wallet addresses
-     */
-    getLinkedWallets(agentId: bigint): Promise<Address[]>;
-    /**
-     * Get agent ID for a wallet (for trade attribution)
-     * @param wallet The wallet address
-     * @returns Agent ID (0 if not linked)
-     */
-    getAgentForWallet(wallet: Address): Promise<bigint>;
-    /**
-     * Check if a wallet is linked to a specific agent
-     * @param agentId The agent's ID
-     * @param wallet The wallet address to check
-     * @returns True if the wallet is linked to the agent
-     */
-    isLinkedWallet(agentId: bigint, wallet: Address): Promise<boolean>;
-    /**
-     * Get the nonce for wallet linking signature
-     * @param wallet The wallet address
-     * @returns Current nonce
-     */
-    getNonce(wallet: Address): Promise<bigint>;
-    /**
-     * Generate the message hash for wallet linking.
-     * Matches the contract's keccak256(abi.encodePacked(...)) exactly.
-     * Sign the returned hash with signMessage({ raw: hash }) to produce a valid signature.
-     * @param wallet The wallet to link
-     * @param agentId The agent ID to link to
-     * @param nonce The current nonce for the wallet
-     * @returns keccak256 hash of the packed message (32 bytes)
-     */
-    static generateLinkMessage(wallet: Address, agentId: bigint, nonce: bigint): Hex;
-    /**
-     * Get the agent owned by a wallet (not linked, owned)
-     * @param wallet The wallet to look up
-     * @returns Agent ID (0 if wallet doesn't own an agent)
-     */
-    getAgentByOwner(wallet: Address): Promise<bigint>;
-    /**
-     * Check if a wallet can register a new agent
-     * @param wallet The wallet to check
-     * @returns Object with canRegister boolean and existingAgentId (0 if none)
-     */
-    canWalletRegister(wallet: Address): Promise<{
-        canRegister: boolean;
-        existingAgentId: bigint;
-    }>;
-    /**
-     * Update the agent's LLM config hash on-chain
-     * @param agentId The agent's ID
-     * @param configHash The keccak256 hash of (provider, model)
-     * @returns Transaction hash
-     */
-    updateConfig(agentId: bigint, configHash: `0x${string}`): Promise<Hash>;
-    /**
-     * Get the current config hash for an agent
-     * @param agentId The agent's ID
-     * @returns Config hash (bytes32(0) if never set)
-     */
-    getConfigHash(agentId: bigint): Promise<`0x${string}`>;
-    /**
-     * Calculate the config hash for a provider and model
-     * @param provider The LLM provider name (e.g., "openai", "anthropic")
-     * @param model The model name (e.g., "gpt-4", "claude-opus-4.5")
-     * @returns keccak256 hash of the config
-     */
-    static calculateConfigHash(provider: string, model: string): `0x${string}`;
-    /**
-     * Retire an agent — marks it as retired, unlinks all wallets, allows new agent registration
-     * @param agentId The agent's ID
-     * @returns Transaction hash
-     */
-    retireAgent(agentId: bigint): Promise<Hash>;
-    /**
-     * Check if an agent is retired
-     * @param agentId The agent's ID
-     * @returns True if agent is retired
-     */
-    isRetired(agentId: bigint): Promise<boolean>;
-    /**
-     * Check if a token trade is allowed for an agent's risk universe
-     * @param agentId The agent's ID
-     * @param token The token address to check
-     * @param aggregator The aggregator being used (for trusted aggregator bypass)
-     * @returns True if the trade is allowed
-     */
-    isTradeAllowed(agentId: bigint, token: Address, aggregator: Address): Promise<boolean>;
-    /**
-     * Get the risk universe for an agent
-     * @param agentId The agent's ID
-     * @returns Risk universe (0=Core, 1=Established, 2=Derivatives, 3=Emerging, 4=Frontier)
-     */
-    getRiskUniverse(agentId: bigint): Promise<number>;
-    /**
-     * Get trade count for an agent
-     * @param agentId The agent's ID
-     * @returns Number of recorded trades
-     */
-    getTradeCount(agentId: bigint): Promise<bigint>;
+interface TradeRecord {
+    token: string;
+    action: 'buy' | 'sell';
+    quantity: number;
+    price: number;
+    fee: number;
+    timestamp: number;
+    venue?: string;
+    chain?: string;
+    venueFillId?: string;
 }
-
-/**
- * Vault info
- */
-interface VaultInfo {
-    address: Address;
-    name: string;
-    symbol: string;
-    asset: Address;
-    agentId: bigint;
-    totalAssets: bigint;
-    totalSupply: bigint;
-    sharePrice: bigint;
-    highWaterMark: bigint;
-    performanceFeeBps: bigint;
-    managementFeeBps: bigint;
-    feeRecipient: Address;
-    depositsPaused: boolean;
-    withdrawalsPaused: boolean;
-    circuitBreakerActive: boolean;
+interface PositionSummary {
+    openPositions: TrackedPosition[];
+    totalUnrealizedPnL: number;
+    totalRealizedPnL: number;
 }
-/**
- * User's vault position
- */
-interface VaultPosition {
-    shares: bigint;
-    effectiveShares: bigint;
-    pendingWithdrawals: bigint;
-    assetsValue: bigint;
-    userHighWaterMark: bigint;
+interface RiskParams {
+    maxPositionSizeBps: number;
+    maxDailyLossBps: number;
+    maxConcurrentPositions: number;
+    maxSlippageBps: number;
+    minTradeValueUSD: number;
+    confidenceThreshold?: number;
 }
-/**
- * Withdrawal request details
- */
-interface WithdrawalRequest {
-    requestId: bigint;
-    owner: Address;
-    receiver: Address;
-    shares: bigint;
-    requestTime: bigint;
-    processed: boolean;
-    claimableAt: bigint;
+interface PaperTrade {
+    id: string;
+    symbol: string;
+    side: 'buy' | 'sell';
+    size: number;
+    entryPrice: number;
+    exitPrice?: number;
+    fee: number;
+    pnl?: number;
+    timestamp: number;
+    venue: string;
 }
-/**
- * ExagentVault SDK interface for ERC-4626 copy trading vaults
- */
-declare class ExagentVault {
-    readonly address: Address;
-    private readonly publicClient;
-    private readonly walletClient?;
-    private readonly chain;
-    private readonly account?;
-    constructor(vaultAddress: Address, publicClient: any, walletClient?: any, chain?: Chain, account?: Account);
-    /**
-     * Get comprehensive vault info
-     */
-    getVaultInfo(): Promise<VaultInfo>;
-    /**
-     * Get user's position in the vault
-     */
-    getPosition(user: Address): Promise<VaultPosition>;
-    /**
-     * Get current share price (assets per share, scaled to 1e18)
-     */
-    getSharePrice(): Promise<bigint>;
-    /**
-     * Preview deposit - get shares for given assets
-     */
-    previewDeposit(assets: bigint): Promise<bigint>;
-    /**
-     * Preview withdrawal - get assets for given shares
-     */
-    previewRedeem(shares: bigint): Promise<bigint>;
-    /**
-     * Get max deposit amount
-     */
-    maxDeposit(receiver: Address): Promise<bigint>;
-    /**
-     * Get max withdrawal amount
-     */
-    maxWithdraw(owner: Address): Promise<bigint>;
-    /**
-     * Get rate limit status
-     */
-    getRateLimitStatus(): Promise<{
-        remaining: bigint;
-        periodEnds: bigint;
+interface PaperPortfolio {
+    cash: number;
+    positions: Map<string, {
+        quantity: number;
+        avgPrice: number;
     }>;
-    /**
-     * Get pending withdrawal request
-     */
-    getPendingWithdrawal(requestId: bigint): Promise<WithdrawalRequest>;
-    /**
-     * Deposit assets into the vault
-     * @param assets Amount of underlying asset to deposit
-     * @param receiver Address to receive vault shares
-     * @returns Transaction hash
-     */
-    deposit(assets: bigint, receiver?: Address): Promise<Hash>;
-    /**
-     * Withdraw assets from the vault
-     * @param assets Amount of underlying asset to withdraw
-     * @param receiver Address to receive assets
-     * @param owner Address whose shares to burn (defaults to caller)
-     * @returns Transaction hash
-     */
-    withdraw(assets: bigint, receiver?: Address, owner?: Address): Promise<Hash>;
-    /**
-     * Redeem shares for assets
-     * @param shares Amount of shares to redeem
-     * @param receiver Address to receive assets
-     * @param owner Address whose shares to burn (defaults to caller)
-     * @returns Transaction hash
-     */
-    redeem(shares: bigint, receiver?: Address, owner?: Address): Promise<Hash>;
-    /**
-     * Redeem all shares safely — charges performance fee first, then redeems remaining balance.
-     * Use this instead of redeem(fullBalance) to avoid ERC4626ExceededMaxRedeem revert.
-     * @param receiver Address to receive assets
-     * @param owner Address whose shares to burn (defaults to caller)
-     * @returns Transaction hash
-     */
-    redeemMax(receiver?: Address, owner?: Address): Promise<Hash>;
-    /**
-     * Withdraw all assets safely — charges performance fee first, then withdraws remaining balance.
-     * @param receiver Address to receive assets
-     * @param owner Address whose shares to burn (defaults to caller)
-     * @returns Transaction hash
-     */
-    withdrawMax(receiver?: Address, owner?: Address): Promise<Hash>;
-    /**
-     * Request a queued withdrawal (for large amounts)
-     * @param shares Amount of shares to withdraw
-     * @param receiver Address to receive assets
-     * @returns Transaction hash
-     */
-    requestWithdrawal(shares: bigint, receiver?: Address): Promise<Hash>;
-    /**
-     * Claim a pending withdrawal request
-     * @param requestId The withdrawal request ID
-     * @returns Transaction hash
-     */
-    claimWithdrawal(requestId: bigint): Promise<Hash>;
-    /**
-     * Cancel a pending withdrawal request
-     * @param requestId The withdrawal request ID
-     * @returns Transaction hash
-     */
-    cancelWithdrawal(requestId: bigint): Promise<Hash>;
-    /**
-     * Emergency withdrawal with penalty (50% if vault < 7 days old, 20% otherwise).
-     * Penalty stays in the vault for remaining backers.
-     * @returns Transaction hash
-     */
-    emergencyWithdraw(): Promise<Hash>;
-    /**
-     * Approve vault to spend underlying asset
-     * @param assetAddress The asset token address
-     * @param amount Amount to approve
-     * @returns Transaction hash
-     */
-    approveAsset(assetAddress: Address, amount: bigint): Promise<Hash>;
+    equity: number;
+    trades: PaperTrade[];
+    equityCurve: {
+        timestamp: number;
+        equity: number;
+    }[];
 }
-
-/** SDK version — sent to API for version gating */
-declare const SDK_VERSION = "0.1.18";
-/**
- * Default RPC URL for Base mainnet.
- * Coinbase's official Base RPC — reliable for reads and transactions.
- * Users should set BASE_RPC_URL env var for higher rate limits.
- */
-declare const DEFAULT_RPC_URL = "https://mainnet.base.org";
-/**
- * Get RPC URL from environment or use default.
- */
-declare function getRpcUrl(): string;
-declare const CHAIN_CONFIG: {
-    readonly mainnet: {
-        blockExplorers: {
-            readonly default: {
-                readonly name: "Basescan";
-                readonly url: "https://basescan.org";
-                readonly apiUrl: "https://api.basescan.org/api";
-            };
+interface PaperMetrics {
+    totalReturn: number;
+    sharpeRatio: number;
+    maxDrawdown: number;
+    winRate: number;
+    profitFactor: number;
+    totalTrades: number;
+}
+type AgentMode = 'idle' | 'trading' | 'paper' | 'paused';
+type CommandType = 'start_trading' | 'stop_trading' | 'pause_trading' | 'update_risk_params' | 'update_strategy' | 'reload_config' | 'get_status' | 'close_all_positions' | 'shutdown';
+type MessageType = 'trade_executed' | 'perp_fill' | 'prediction_fill' | 'spot_fill' | 'bridge_fill' | 'strategy_decision' | 'risk_blocked' | 'error' | 'info' | 'funds_low' | 'daily_limit_hit' | 'started' | 'stopped';
+type MessageLevel = 'info' | 'warning' | 'error' | 'success';
+interface RelayCommand {
+    id: string;
+    type: CommandType;
+    params?: Record<string, unknown>;
+}
+interface AgentStatusPayload {
+    mode: AgentMode;
+    agentId: string;
+    walletAddress?: string;
+    sdkVersion?: string;
+    cycleCount?: number;
+    lastCycleAt?: number;
+    tradingIntervalMs?: number;
+    portfolioValue?: number;
+    llm?: {
+        provider: string;
+        model: string;
+        dailyTokens?: number;
+        totalTokens?: number;
+        dailyCalls?: number;
+        totalCalls?: number;
+        dailyBudgetExceeded?: boolean;
+    };
+    risk?: {
+        dailyPnL: number;
+        dailyLossLimit: number;
+        isLimitHit: boolean;
+    };
+    positions?: {
+        openPositions: number;
+        totalUnrealizedPnL: number;
+        totalRealizedPnL: number;
+    };
+    paper?: {
+        active: boolean;
+        simulatedValue: number;
+        simulatedPnLPct: number;
+    };
+    venues?: {
+        hyperliquid?: {
+            enabled: boolean;
+            trading: boolean;
         };
-        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";
-            };
+        polymarket?: {
+            enabled: boolean;
+            trading: boolean;
         };
-        ensTlds?: readonly string[] | undefined;
-        id: 8453;
-        name: "Base";
-        nativeCurrency: {
-            readonly name: "Ether";
-            readonly symbol: "ETH";
-            readonly decimals: 18;
+        spot?: {
+            enabled: boolean;
+            trading: boolean;
         };
-        experimental_preconfirmationTime?: number | undefined | undefined;
-        rpcUrls: {
-            readonly default: {
-                readonly http: readonly ["https://mainnet.base.org"];
-            };
+        bridge?: {
+            enabled: boolean;
         };
-        sourceId: 1;
-        testnet?: boolean | undefined | undefined;
-        custom?: Record<string, unknown> | undefined;
-        extendSchema?: Record<string, unknown> | undefined;
-        fees?: viem.ChainFees<undefined> | undefined;
-        formatters: {
-            readonly block: {
-                exclude: [] | undefined;
-                format: (args: viem_chains.OpStackRpcBlock, action?: string | undefined) => {
-                    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, action?: string | 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;
-                    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, action?: string | undefined) => {
-                    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";
-            };
+    };
+    diagnostics?: {
+        uptime?: number;
+        uptimeHuman?: string;
+        memoryMB?: number;
+        cycleStats?: {
+            total: number;
+            succeeded: number;
+            failed: number;
+            successRate: number;
+            avgCycleMs: number;
+            lastCycleMs: number;
+        };
+        lastCycleTimings?: {
+            totalMs: number;
+            priceRefreshMs: number;
+            strategyMs: number;
+            riskFilterMs: number;
+            executionMs: number;
         };
-        prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
-            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
-        }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
-            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
-        }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
-            runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
-        }] | undefined;
-        serializers: {
-            readonly transaction: typeof viem_chains.serializeTransactionOpStack;
+        errorCounts?: Record<string, number>;
+        recentErrors?: Array<{
+            category: string;
+            message: string;
+            timestamp: number;
+        }>;
+        llmStats?: {
+            totalCalls: number;
+            avgLatencyMs: number;
+            errorRate: number;
+            recentCalls: number;
+        };
+        signalQueue?: {
+            pending: number;
+            flushedTotal: number;
         };
-        verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
     };
+}
+interface AgentRelayMessage {
+    type: 'message';
+    agentId: string;
+    messageType: MessageType;
+    level: MessageLevel;
+    title: string;
+    body: string;
+    data?: Record<string, unknown>;
+    timestamp: number;
+}
+interface HeartbeatMessage {
+    type: 'heartbeat';
+    agentId: string;
+    status: AgentStatusPayload;
+    timestamp: number;
+}
+interface TradeSignalMessage {
+    type: 'trade_signal';
+    agentId: string;
+    signal: TradeSignal;
+    timestamp: number;
+}
+interface CommandAckMessage {
+    type: 'command_ack';
+    agentId: string;
+    commandId: string;
+    success: boolean;
+    message?: string;
+    timestamp: number;
+}
+type AgentToAPIMessage = {
+    type: 'auth';
+    agentId: string;
+    token: string;
+} | HeartbeatMessage | AgentRelayMessage | TradeSignalMessage | CommandAckMessage;
+type APIToAgentMessage = {
+    type: 'auth_success';
+    agentId: string;
+} | {
+    type: 'auth_error';
+    error: string;
+} | {
+    type: 'command';
+    command: RelayCommand;
+} | {
+    type: 'pong';
 };
-type NetworkType = 'mainnet';
-/**
- * Contract addresses by network
- */
-declare const CONTRACT_ADDRESSES: Record<NetworkType, {
-    agentRegistry: Address;
-    router: Address;
-    vaultFactory: Address;
-    feeCollector: Address;
-    serviceEscrow: Address;
-}>;
-/**
- * DEX router addresses on Base
- */
-declare const DEX_ADDRESSES: {
-    readonly aerodromeRouter: Address;
-    readonly aerodromeSlipstream: Address;
-    readonly uniswapUniversalRouter: Address;
-    readonly uniswapV4Router: Address;
-    readonly WETH: Address;
-    readonly USDC: Address;
-};
-/**
- * 0x API configuration
- */
-declare const ZERO_X_CONFIG: {
-    readonly baseUrl: "https://api.0x.org";
-    readonly chainId: 8453;
-};
-/**
- * Exagent API configuration
- */
-declare const EXAGENT_API_CONFIG: {
-    readonly mainnet: "https://exagent-api.onrender.com";
+type APIToDashboardMessage = {
+    type: 'agent_status';
+    agentId: string;
+    status: AgentStatusPayload;
+} | {
+    type: 'agent_message';
+    message: AgentRelayMessage;
+} | {
+    type: 'agent_connected';
+    agentId: string;
+} | {
+    type: 'agent_disconnected';
+    agentId: string;
+} | {
+    type: 'trade_signal';
+    agentId: string;
+    signal: TradeSignal;
+} | {
+    type: 'command_ack';
+    agentId: string;
+    commandId: string;
+    success: boolean;
+    message?: string;
 };
+declare const tradeSignalSchema: z.ZodObject<{
+    venue: z.ZodString;
+    chain: z.ZodOptional<z.ZodString>;
+    symbol: z.ZodString;
+    side: z.ZodEnum<["long", "short", "buy", "sell"]>;
+    size: z.ZodNumber;
+    price: z.ZodNumber;
+    fee: z.ZodNumber;
+    venueFillId: z.ZodString;
+    venueTimestamp: z.ZodString;
+    leverage: z.ZodOptional<z.ZodNumber>;
+    orderType: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    reasoning: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    symbol: string;
+    venue: string;
+    side: "long" | "short" | "buy" | "sell";
+    size: number;
+    price: number;
+    fee: number;
+    venueFillId: string;
+    venueTimestamp: string;
+    chain?: string | undefined;
+    leverage?: number | undefined;
+    orderType?: string | undefined;
+    confidence?: number | undefined;
+    reasoning?: string | undefined;
+}, {
+    symbol: string;
+    venue: string;
+    side: "long" | "short" | "buy" | "sell";
+    size: number;
+    price: number;
+    fee: number;
+    venueFillId: string;
+    venueTimestamp: string;
+    chain?: string | undefined;
+    leverage?: number | undefined;
+    orderType?: string | undefined;
+    confidence?: number | undefined;
+    reasoning?: string | undefined;
+}>;
+declare const tradingConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<["live", "paper"]>>;
+    timeHorizon: z.ZodDefault<z.ZodEnum<["intraday", "swing", "position"]>>;
+    maxPositionSizeBps: z.ZodDefault<z.ZodNumber>;
+    maxDailyLossBps: z.ZodDefault<z.ZodNumber>;
+    maxConcurrentPositions: z.ZodDefault<z.ZodNumber>;
+    tradingIntervalMs: z.ZodDefault<z.ZodNumber>;
+    maxSlippageBps: z.ZodDefault<z.ZodNumber>;
+    minTradeValueUSD: z.ZodDefault<z.ZodNumber>;
+    initialCapitalUSD: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    mode: "live" | "paper";
+    timeHorizon: "intraday" | "swing" | "position";
+    maxPositionSizeBps: number;
+    maxDailyLossBps: number;
+    maxConcurrentPositions: number;
+    tradingIntervalMs: number;
+    maxSlippageBps: number;
+    minTradeValueUSD: number;
+    initialCapitalUSD?: number | undefined;
+}, {
+    mode?: "live" | "paper" | undefined;
+    timeHorizon?: "intraday" | "swing" | "position" | undefined;
+    maxPositionSizeBps?: number | undefined;
+    maxDailyLossBps?: number | undefined;
+    maxConcurrentPositions?: number | undefined;
+    tradingIntervalMs?: number | undefined;
+    maxSlippageBps?: number | undefined;
+    minTradeValueUSD?: number | undefined;
+    initialCapitalUSD?: number | undefined;
+}>;
 
-/**
- * Configuration for ExagentClient
- */
 interface ExagentClientConfig {
-    /** Network to connect to */
-    network?: NetworkType;
-    /** Private key for the agent's wallet */
-    privateKey?: `0x${string}`;
-    /** Pre-configured wallet client */
-    walletClient?: WalletClient;
-    /** RPC URL override */
-    rpcUrl?: string;
-    /** Exagent API key (optional, for enhanced features) */
-    apiKey?: string;
+    baseUrl: string;
+    token: string;
 }
-/**
- * Main client for interacting with Exagent
- *
- * @example
- * ```typescript
- * import { ExagentClient } from '@exagent/sdk';
- *
- * const exagent = new ExagentClient({
- *   privateKey: process.env.AGENT_PRIVATE_KEY,
- *   network: 'mainnet',
- * });
- *
- * // Register agent
- * const agentId = await exagent.register({
- *   name: 'My Trading Agent',
- *   description: 'Momentum-based trading strategy',
- *   capabilities: ['spot_trading'],
- * });
- *
- * // Execute trade (always through ExagentRouter for attribution + fees)
- * const result = await exagent.trade({
- *   tokenIn: WETH,
- *   tokenOut: USDC,
- *   amountIn: parseEther('1'),
- *   maxSlippageBps: 50,
- * });
- * console.log('Trade submitted:', result.hash);
- * ```
- */
 declare class ExagentClient {
-    private readonly publicClient;
-    private readonly walletClient;
-    private readonly account;
-    private readonly network;
-    private readonly apiKey?;
-    readonly registry: ExagentRegistry;
-    private _agentId?;
+    private baseUrl;
+    private token;
     constructor(config: ExagentClientConfig);
-    /** Standard headers for all API requests (includes SDK version for gating) */
-    private apiHeaders;
-    /**
-     * Register as a new agent on Exagent.
-     *
-     * RECOMMENDED: Register your agent at https://exagent.io instead of using this method.
-     * The website handles the full registration flow including risk universe selection,
-     * position size limits, daily loss limits, and metadata upload — all in one step.
-     * After registering on the website, use your agent ID in agent-config.json.
-     *
-     * This SDK method is available for programmatic registration but uses default
-     * risk parameters (universe=1, maxPositionSize=10%, maxDailyLoss=5%).
-     *
-     * @param metadata Agent metadata (will be uploaded to IPFS)
-     * @returns The assigned agent ID
-     * @throws Error if wallet already owns an agent (one agent per wallet rule)
-     */
-    register(metadata: AgentMetadata): Promise<bigint>;
-    /**
-     * Check if an agent name is available for registration
-     * @param name The name to check
-     * @returns True if the name is available
-     */
-    isNameAvailable(name: string): Promise<boolean>;
-    /**
-     * Get agent by name (returns 0 if not found)
-     * @param name The agent name to look up
-     * @returns Agent ID or 0 if not found
-     */
-    getAgentByName(name: string): Promise<bigint>;
-    /**
-     * Get the current agent's ID (if registered).
-     *
-     * Resolution order:
-     * 1. Cached value (from prior register() or getAgentId() call)
-     * 2. walletToAgent mapping (linked wallets)
-     * 3. Owner lookup (unlinked owner wallet)
-     *
-     * If the agent was just registered, public RPCs may return stale data (0).
-     * Use `retries` to wait for the on-chain state to propagate.
-     *
-     * @param retries Number of retries with 2s delay for stale RPC reads (default: 0)
-     */
-    getAgentId(retries?: number): Promise<bigint | undefined>;
-    /**
-     * Get agent profile
-     * @param agentId Optional agent ID (defaults to current agent)
-     */
-    getAgent(agentId?: bigint): Promise<AgentProfile>;
-    /**
-     * Link an additional wallet to this agent
-     * @param wallet Wallet address to link
-     * @param signMessage Function to sign the message hash with the wallet (use signMessage({ raw: hash }))
-     */
-    linkWallet(wallet: Address, signMessage: (message: {
-        raw: `0x${string}`;
-    }) => Promise<`0x${string}`>): Promise<Hash>;
-    /**
-     * Get all wallets linked to this agent
-     */
-    getLinkedWallets(): Promise<Address[]>;
-    /**
-     * Execute a trade through ExagentRouter
-     *
-     * All trades MUST go through the ExagentRouter. This ensures:
-     * - Trade attribution for leaderboard ranking
-     * - Protocol fee collection (0.2%)
-     * - On-chain performance tracking
-     * - Token whitelist enforcement per risk universe
-     *
-     * There is no way to trade outside the router. This is by design.
-     *
-     * @param intent Trade parameters
-     * @returns Trade result with transaction hash
-     *
-     * @example
-     * ```typescript
-     * const result = await exagent.trade({
-     *   tokenIn: WETH,
-     *   tokenOut: USDC,
-     *   amountIn: parseEther('1'),
-     *   maxSlippageBps: 50,
-     * });
-     * console.log('Trade submitted:', result.hash);
-     * ```
-     */
-    trade(intent: Omit<TradeIntent, 'action'>): Promise<TradeResult>;
-    /**
-     * Build a router trade transaction without executing
-     * Useful for simulation or multi-step workflows
-     */
-    buildRouterTrade(intent: Omit<TradeIntent, 'action'>, agentId?: bigint): Promise<RouterTradeResponse>;
-    /**
-     * Check if an address is the ETH sentinel or WETH
-     */
-    private isETHAddress;
-    /**
-     * Read current ERC-20 allowance for a (token, spender) pair
-     */
-    private getAllowance;
-    /**
-     * Approve token spending for router.
-     * Verifies the approval receipt succeeded — previous version silently continued
-     * on reverted approvals, causing downstream "transfer amount exceeds allowance" errors.
-     */
-    private approveToken;
-    /**
-     * Encode ERC20 approve calldata
-     */
-    private encodeApprove;
-    /**
-     * Request a service from another agent
-     */
-    requestService(request: ServiceRequest): Promise<{
-        requestId: string;
-    }>;
-    /**
-     * List available services
-     */
-    listServices(serviceType?: string): Promise<unknown[]>;
-    /**
-     * Get agent leaderboard
-     */
-    getLeaderboard(options?: {
-        category?: string;
-        limit?: number;
-        offset?: number;
-    }): Promise<AgentProfile[]>;
-    /**
-     * Get a vault interface for interacting with an ExagentVault
-     * @param vaultAddress The vault contract address
-     * @returns ExagentVault instance
-     */
-    getVault(vaultAddress: Address): ExagentVault;
-    /**
-     * List all vaults for a given agent
-     * @param agentId Agent ID to get vaults for
-     * @returns Array of vault summaries
-     */
-    getAgentVaults(agentId?: bigint): Promise<VaultSummary[]>;
-    /**
-     * List all vaults the user has positions in
-     * @param userAddress User address (defaults to connected wallet)
-     * @returns Array of vault summaries with user position info
-     */
-    getUserVaults(userAddress?: Address): Promise<VaultSummary[]>;
-    /**
-     * List top performing vaults
-     * @param options Filter options
-     * @returns Array of vault summaries sorted by performance
-     */
-    getTopVaults(options?: {
-        asset?: Address;
-        minTvl?: bigint;
-        period?: '7d' | '30d' | '90d' | 'all';
-        limit?: number;
-    }): Promise<VaultSummary[]>;
-    /**
-     * Deposit into a vault
-     * @param vaultAddress Vault contract address
-     * @param amount Amount of underlying asset to deposit
-     * @returns Transaction hash
-     */
-    depositToVault(vaultAddress: Address, amount: bigint): Promise<Hash>;
-    /**
-     * Withdraw from a vault
-     * @param vaultAddress Vault contract address
-     * @param assets Amount of underlying asset to withdraw
-     * @returns Transaction hash
-     */
-    withdrawFromVault(vaultAddress: Address, assets: bigint): Promise<Hash>;
-    /**
-     * Redeem shares from a vault
-     * @param vaultAddress Vault contract address
-     * @param shares Amount of shares to redeem
-     * @returns Transaction hash
-     */
-    redeemFromVault(vaultAddress: Address, shares: bigint): Promise<Hash>;
-    /**
-     * Get the ERC-8004 global agent identifier for the current agent
-     *
-     * Format: eip155:{chainId}:{registryAddress}:{agentId}
-     *
-     * This creates a universally unique identifier that can be used for
-     * cross-protocol agent discovery and interoperability.
-     *
-     * @returns The global agent ID string
-     * @throws Error if agent is not registered
-     *
-     * @example
-     * ```typescript
-     * const globalId = await exagent.getGlobalAgentId();
-     * // => "eip155:8453:0xABC...DEF:42"
-     * ```
-     */
-    getGlobalAgentId(): Promise<GlobalAgentId>;
-    /**
-     * Build a global agent ID for any agent (static utility)
-     *
-     * @param chainId - EVM chain ID
-     * @param registryAddress - ExagentRegistry contract address
-     * @param agentId - On-chain agent ID
-     * @returns ERC-8004 global agent identifier
-     */
-    static buildGlobalAgentId(chainId: number, registryAddress: Address, agentId: number | bigint): GlobalAgentId;
-    /**
-     * Get the agent's wallet address
-     */
-    get address(): Address;
-    /**
-     * Sign a message with the wallet's private key (EIP-191 personal sign)
-     * @param message The message to sign — string for UTF-8, or { raw: Hex } for raw bytes
-     * @returns The signature
-     */
-    signMessage(message: string | {
-        raw: `0x${string}`;
-    }): Promise<`0x${string}`>;
-    private uploadMetadata;
-    private parseAgentIdFromReceipt;
-}
-
-/**
- * ABI for ExagentRouter custom errors
- * Used for decoding revert reasons from router transactions
- */
-declare const EXAGENT_ROUTER_ABI: readonly [{
-    readonly type: "error";
-    readonly name: "InvalidAgentId";
-    readonly inputs: readonly [];
-}, {
-    readonly type: "error";
-    readonly name: "SwapFailed";
-    readonly inputs: readonly [];
-}, {
-    readonly type: "error";
-    readonly name: "InsufficientOutput";
-    readonly inputs: readonly [];
-}, {
-    readonly type: "error";
-    readonly name: "ZeroAddress";
-    readonly inputs: readonly [];
-}, {
-    readonly type: "error";
-    readonly name: "ZeroAmount";
-    readonly inputs: readonly [];
-}, {
-    readonly type: "error";
-    readonly name: "AggregatorNotWhitelisted";
-    readonly inputs: readonly [];
-}, {
-    readonly type: "error";
-    readonly name: "ETHTransferFailed";
-    readonly inputs: readonly [];
-}, {
-    readonly type: "error";
-    readonly name: "FeeBpsTooHigh";
-    readonly inputs: readonly [];
-}, {
-    readonly type: "error";
-    readonly name: "NotAuthorizedForAgent";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-    }, {
-        readonly name: "caller";
-        readonly type: "address";
-    }];
-}, {
-    readonly type: "error";
-    readonly name: "ConfigMismatch";
-    readonly inputs: readonly [{
-        readonly name: "provided";
-        readonly type: "bytes32";
-    }, {
-        readonly name: "onChain";
-        readonly type: "bytes32";
-    }];
-}, {
-    readonly type: "error";
-    readonly name: "MsgValueMismatch";
-    readonly inputs: readonly [];
-}, {
-    readonly type: "error";
-    readonly name: "FeeCollectorNotSet";
-    readonly inputs: readonly [];
-}, {
-    readonly type: "error";
-    readonly name: "TokenNotAllowedForAgent";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-    }, {
-        readonly name: "token";
-        readonly type: "address";
-    }];
-}, {
-    readonly type: "error";
-    readonly name: "NotAuthorized";
-    readonly inputs: readonly [];
-}, {
-    readonly type: "error";
-    readonly name: "RiskUniverseTooLow";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-    }, {
-        readonly name: "riskUniverse";
-        readonly type: "uint256";
-    }];
-}, {
-    readonly type: "error";
-    readonly name: "FillAlreadyProcessed";
-    readonly inputs: readonly [{
-        readonly name: "fillId";
-        readonly type: "bytes32";
-    }];
-}];
-
-/**
- * ExagentVaultFactory ABI (Mainnet — no burn fee, seed-based creation)
- */
-declare const EXAGENT_VAULT_FACTORY_ABI: readonly [{
-    readonly type: "function";
-    readonly name: "owner";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly type: "address";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "registry";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly type: "address";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "router";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly type: "address";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "feeCollector";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly type: "address";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "stakingContract";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly type: "address";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "VERIFIED_VEXA_REQUIREMENT";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "MIN_SEED_AMOUNT";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "UNVERIFIED_CAP_MULTIPLIER";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "VERIFIED_CAP_MULTIPLIER";
-    readonly inputs: readonly [];
-    readonly outputs: readonly [{
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "allowedAssets";
-    readonly inputs: readonly [{
-        readonly name: "asset";
-        readonly type: "address";
-    }];
-    readonly outputs: readonly [{
-        readonly type: "bool";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "vaults";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-    }, {
-        readonly name: "asset";
-        readonly type: "address";
-    }];
-    readonly outputs: readonly [{
-        readonly type: "address";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "agentVaultCount";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-    }];
-    readonly outputs: readonly [{
-        readonly type: "uint256";
-    }];
-    readonly stateMutability: "view";
-}, {
-    readonly type: "function";
-    readonly name: "createVault";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-    }, {
-        readonly name: "asset";
-        readonly type: "address";
-    }, {
-        readonly name: "seedAmount";
-        readonly type: "uint256";
-    }, {
-        readonly name: "name";
-        readonly type: "string";
-    }, {
-        readonly name: "symbol";
-        readonly type: "string";
-    }, {
-        readonly name: "feeRecipient";
-        readonly type: "address";
-    }];
-    readonly outputs: readonly [{
-        readonly type: "address";
-    }];
-    readonly stateMutability: "nonpayable";
-}, {
-    readonly type: "event";
-    readonly name: "VaultCreated";
-    readonly inputs: readonly [{
-        readonly name: "vault";
-        readonly type: "address";
-        readonly indexed: true;
-    }, {
-        readonly name: "agentId";
-        readonly type: "uint256";
-        readonly indexed: true;
-    }, {
-        readonly name: "asset";
-        readonly type: "address";
-        readonly indexed: true;
-    }, {
-        readonly name: "creator";
-        readonly type: "address";
-        readonly indexed: false;
-    }, {
-        readonly name: "name";
-        readonly type: "string";
-        readonly indexed: false;
-    }, {
-        readonly name: "symbol";
-        readonly type: "string";
-        readonly indexed: false;
-    }];
-}, {
-    readonly type: "event";
-    readonly name: "AllowedAssetUpdated";
-    readonly inputs: readonly [{
-        readonly name: "asset";
-        readonly type: "address";
-        readonly indexed: true;
-    }, {
-        readonly name: "allowed";
-        readonly type: "bool";
-        readonly indexed: false;
-    }];
-}];
-/**
- * Vault creation requirements from the mainnet factory
- */
-interface VaultCreationRequirements {
-    minSeedAmount: bigint;
-    unverifiedCapMultiplier: bigint;
-    verifiedCapMultiplier: bigint;
-}
-/**
- * Result of checking if an address can create a vault
- */
-interface CanCreateVaultResult {
-    canCreate: boolean;
-    reason: string;
-}
-/**
- * Options for creating a vault
- */
-interface CreateVaultOptions {
-    agentId: bigint;
-    asset: Address;
-    seedAmount: bigint;
-    name: string;
-    symbol: string;
-    feeRecipient?: Address;
-}
-/**
- * ExagentVaultFactory SDK class for vault creation and management
- */
-declare class ExagentVaultFactory {
-    readonly address: Address;
-    private readonly publicClient;
-    private readonly walletClient?;
-    private readonly chain;
-    private readonly account?;
-    constructor(factoryAddress: Address, publicClient: any, walletClient?: any, chain?: Chain, account?: Account);
-    /**
-     * Get vault creation requirements (mainnet: seed-based, no burn fee)
-     */
-    getRequirements(): Promise<VaultCreationRequirements>;
-    /**
-     * Check if an address can create a vault.
-     * Performs inline validation since the on-chain contract does not expose
-     * a canCreateVault() view function.
-     * @param creator Address to check
-     */
-    canCreateVault(creator: Address): Promise<CanCreateVaultResult>;
-    /**
-     * Check if an asset is whitelisted for vault creation
-     * @param asset Asset address to check
-     */
-    isAssetAllowed(asset: Address): Promise<boolean>;
-    /**
-     * Get existing vault for an agent and asset
-     * @param agentId Agent ID
-     * @param asset Asset address
-     * @returns Vault address or zero address if none exists
-     */
-    getVault(agentId: bigint, asset: Address): Promise<Address>;
-    /**
-     * Get count of vaults for an agent
-     * @param agentId Agent ID
-     */
-    getAgentVaultCount(agentId: bigint): Promise<bigint>;
-    /**
-     * Check if agent already has a vault for an asset
-     * @param agentId Agent ID
-     * @param asset Asset address
-     */
-    hasVault(agentId: bigint, asset: Address): Promise<boolean>;
-    /**
-     * Create a new vault for an agent (mainnet: requires seed amount)
-     * @param options Vault creation options including seedAmount
-     * @returns Transaction hash
-     */
-    createVault(options: CreateVaultOptions): Promise<Hash>;
-    /**
-     * Check all requirements and create a vault if possible
-     * Returns detailed status about each requirement
-     */
-    checkAndCreateVault(agentId: bigint, asset: Address, seedAmount: bigint, name: string, symbol: string, feeRecipient?: Address): Promise<{
-        success: boolean;
-        vaultAddress?: Address;
-        txHash?: Hash;
-        error?: string;
-        checks: {
-            canCreate: boolean;
-            canCreateReason: string;
-            assetAllowed: boolean;
-            hasExistingVault: boolean;
-        };
-    }>;
+    private request;
+    getMe(): Promise<Record<string, unknown>>;
+    listAgents(): Promise<AgentProfile[]>;
+    getAgent(agentId: string): Promise<AgentProfile>;
+    createAgent(data: {
+        name: string;
+        description?: string;
+        config: Record<string, unknown>;
+    }): Promise<AgentProfile>;
+    reportTradeSignal(agentId: string, signal: TradeSignal): Promise<void>;
+    getWebSocketUrl(): string;
+    getDashboardWebSocketUrl(): string;
 }
 
-export { type AgentMetadata, type AgentProfile, CHAIN_CONFIG, CONTRACT_ADDRESSES, type CanCreateVaultResult, type CreateVaultOptions, DEFAULT_RPC_URL, DEX_ADDRESSES, EXAGENT_API_CONFIG, EXAGENT_REGISTRY_ABI, EXAGENT_ROUTER_ABI, EXAGENT_VAULT_FACTORY_ABI, ExagentClient, type ExagentClientConfig, ExagentRegistry, ExagentVault, ExagentVaultFactory, type GlobalAgentId, type NetworkType, type PerformanceSnapshot, type PriceQuote, type RouteQuote, type RouteStep, type RouterTradeResponse, SDK_VERSION, type ServiceRequest, type TradeIntent, type TradeResult, type UserVaultPosition, type VaultActivityEntry, type VaultConfig, type VaultCreationRequirements, type VaultInfo, type VaultPosition, type VaultSummary, type VaultTradeEntry, type WithdrawalRequest, ZERO_X_CONFIG, buildGlobalAgentId, getRpcUrl, parseGlobalAgentId };
+export { type APIToAgentMessage, type APIToDashboardMessage, type AgentConfig, type AgentMode, type AgentProfile, type AgentRelayMessage, type AgentStatus, type AgentStatusPayload, type AgentToAPIMessage, type CommandType, ExagentClient, type ExagentClientConfig, type HeartbeatMessage, type LLMAdapter, type LLMConfig, type LLMMessage, type LLMMetadata, type LLMProvider, type LLMResponse, type MarketData, type MessageLevel, type MessageType, type OHLCV, type PaperMetrics, type PaperPortfolio, type PaperTrade, type PerpTradeSignal, type PositionSummary, type PredictionTradeSignal, type RelayCommand, type RelayConfig, type RiskParams, type StrategyConfig, type StrategyContext, type StrategyFunction, type StrategyStore, type StrategyTemplate, type TrackedPosition, type TradeRecord, type TradeSignal, type TradeSignalMessage, type TradingConfig, type VenueConfig, tradeSignalSchema, tradingConfigSchema };