@t2000/engine 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,838 @@
+import { z } from 'zod';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import { Tool as Tool$1 } from '@modelcontextprotocol/sdk/types.js';
+import * as _t2000_sdk from '@t2000/sdk';
+import { T2000 } from '@t2000/sdk';
+
+type ContentBlock = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: unknown;
+} | {
+    type: 'tool_result';
+    toolUseId: string;
+    content: string;
+    isError?: boolean;
+};
+interface Message {
+    role: 'user' | 'assistant';
+    content: ContentBlock[];
+}
+type EngineEvent = {
+    type: 'text_delta';
+    text: string;
+} | {
+    type: 'tool_start';
+    toolName: string;
+    toolUseId: string;
+    input: unknown;
+} | {
+    type: 'tool_result';
+    toolName: string;
+    toolUseId: string;
+    result: unknown;
+    isError: boolean;
+} | {
+    type: 'permission_request';
+    toolName: string;
+    toolUseId: string;
+    input: unknown;
+    description: string;
+    resolve: (approved: boolean) => void;
+} | {
+    type: 'turn_complete';
+    stopReason: StopReason;
+} | {
+    type: 'usage';
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+} | {
+    type: 'error';
+    error: Error;
+};
+type StopReason = 'end_turn' | 'tool_use' | 'max_tokens' | 'max_turns' | 'error';
+type PermissionLevel = 'auto' | 'confirm' | 'explicit';
+interface ToolResult<T = unknown> {
+    data: T;
+    displayText?: string;
+}
+interface ToolContext {
+    agent?: unknown;
+    mcpManager?: unknown;
+    walletAddress?: string;
+    signal?: AbortSignal;
+}
+interface ToolJsonSchema {
+    type: 'object';
+    properties: Record<string, unknown>;
+    required?: string[];
+}
+interface Tool<TInput = unknown, TOutput = unknown> {
+    name: string;
+    description: string;
+    inputSchema: z.ZodType<TInput>;
+    jsonSchema: ToolJsonSchema;
+    call(input: TInput, context: ToolContext): Promise<ToolResult<TOutput>>;
+    isConcurrencySafe: boolean;
+    isReadOnly: boolean;
+    permissionLevel: PermissionLevel;
+}
+interface EngineConfig {
+    provider: LLMProvider;
+    agent?: unknown;
+    mcpManager?: unknown;
+    walletAddress?: string;
+    tools?: Tool[];
+    systemPrompt?: string;
+    model?: string;
+    maxTurns?: number;
+    maxTokens?: number;
+    costTracker?: {
+        budgetLimitUsd?: number;
+        inputCostPerToken?: number;
+        outputCostPerToken?: number;
+    };
+}
+interface LLMProvider {
+    chat(params: ChatParams): AsyncGenerator<ProviderEvent>;
+}
+interface ChatParams {
+    messages: Message[];
+    systemPrompt: string;
+    tools: ToolDefinition[];
+    model?: string;
+    maxTokens?: number;
+    signal?: AbortSignal;
+}
+interface ToolDefinition {
+    name: string;
+    description: string;
+    input_schema: ToolJsonSchema;
+}
+type ProviderEvent = {
+    type: 'text_delta';
+    text: string;
+} | {
+    type: 'tool_use_start';
+    id: string;
+    name: string;
+} | {
+    type: 'tool_use_delta';
+    id: string;
+    partialJson: string;
+} | {
+    type: 'tool_use_done';
+    id: string;
+    name: string;
+    input: unknown;
+} | {
+    type: 'message_start';
+    messageId: string;
+    model: string;
+} | {
+    type: 'usage';
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+} | {
+    type: 'stop';
+    reason: StopReason;
+};
+
+interface CostSnapshot {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    totalTokens: number;
+    estimatedCostUsd: number;
+}
+interface CostTrackerConfig {
+    budgetLimitUsd?: number;
+    inputCostPerToken?: number;
+    outputCostPerToken?: number;
+}
+declare class CostTracker {
+    private inputTokens;
+    private outputTokens;
+    private cacheReadTokens;
+    private cacheWriteTokens;
+    private readonly budgetLimitUsd;
+    private readonly inputCost;
+    private readonly outputCost;
+    constructor(config?: CostTrackerConfig);
+    track(inputTokens: number, outputTokens: number, cacheReadTokens?: number, cacheWriteTokens?: number): void;
+    getSnapshot(): CostSnapshot;
+    isOverBudget(): boolean;
+    getRemainingBudgetUsd(): number | null;
+    reset(): void;
+}
+
+declare class QueryEngine {
+    private readonly provider;
+    private readonly tools;
+    private readonly systemPrompt;
+    private readonly model;
+    private readonly maxTurns;
+    private readonly maxTokens;
+    private readonly agent;
+    private readonly mcpManager;
+    private readonly walletAddress;
+    private readonly txMutex;
+    private readonly costTracker;
+    private messages;
+    private abortController;
+    constructor(config: EngineConfig);
+    /**
+     * Submit a user message and receive a stream of engine events.
+     * Handles the full agent loop: LLM → permission check → tool execution → LLM → ...
+     */
+    submitMessage(prompt: string): AsyncGenerator<EngineEvent>;
+    interrupt(): void;
+    getMessages(): readonly Message[];
+    reset(): void;
+    loadMessages(messages: Message[]): void;
+    getUsage(): CostSnapshot;
+    private handleProviderEvent;
+}
+
+interface BuildToolOptions<TInput, TOutput> {
+    name: string;
+    description: string;
+    inputSchema: z.ZodType<TInput>;
+    jsonSchema: ToolJsonSchema;
+    call: (input: TInput, context: ToolContext) => Promise<ToolResult<TOutput>>;
+    isReadOnly?: boolean;
+    permissionLevel?: PermissionLevel;
+}
+declare function buildTool<TInput, TOutput>(opts: BuildToolOptions<TInput, TOutput>): Tool<TInput, TOutput>;
+declare function toolsToDefinitions(tools: Tool[]): {
+    name: string;
+    description: string;
+    input_schema: ToolJsonSchema;
+}[];
+declare function findTool(tools: Tool[], name: string): Tool | undefined;
+
+interface PendingToolCall {
+    id: string;
+    name: string;
+    input: unknown;
+}
+declare class TxMutex {
+    private queue;
+    private locked;
+    acquire(): Promise<void>;
+    release(): void;
+}
+declare function runTools(pending: PendingToolCall[], tools: Tool[], context: ToolContext, txMutex: TxMutex): AsyncGenerator<EngineEvent>;
+
+/**
+ * Wire-safe representation of EngineEvent for SSE transport.
+ * `permission_request` replaces the `resolve` callback with a `permissionId`
+ * that the client sends back via a separate HTTP endpoint.
+ */
+type SSEEvent = {
+    type: 'text_delta';
+    text: string;
+} | {
+    type: 'tool_start';
+    toolName: string;
+    toolUseId: string;
+    input: unknown;
+} | {
+    type: 'tool_result';
+    toolName: string;
+    toolUseId: string;
+    result: unknown;
+    isError: boolean;
+} | {
+    type: 'permission_request';
+    permissionId: string;
+    toolName: string;
+    toolUseId: string;
+    input: unknown;
+    description: string;
+} | {
+    type: 'turn_complete';
+    stopReason: StopReason;
+} | {
+    type: 'usage';
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
+} | {
+    type: 'error';
+    message: string;
+};
+declare function serializeSSE(event: SSEEvent): string;
+declare function parseSSE(raw: string): SSEEvent | null;
+declare class PermissionBridge {
+    private pending;
+    private counter;
+    /**
+     * Register a permission_request resolve callback.
+     * Returns the permissionId to send to the client.
+     */
+    register(resolve: (approved: boolean) => void): string;
+    /**
+     * Resolve a pending permission request from the client.
+     * Returns false if the permissionId is unknown (expired or invalid).
+     */
+    resolve(permissionId: string, approved: boolean): boolean;
+    /** Number of pending (unresolved) permission requests. */
+    get size(): number;
+    /** Reject all pending permissions (e.g., on disconnect). */
+    rejectAll(): void;
+}
+/**
+ * Wraps a QueryEngine.submitMessage() generator, converting EngineEvents
+ * to SSE text. Permission requests are routed through the bridge.
+ */
+declare function engineToSSE(events: AsyncGenerator<EngineEvent>, bridge: PermissionBridge): AsyncGenerator<string>;
+
+interface SessionData {
+    id: string;
+    messages: Message[];
+    usage: CostSnapshot;
+    createdAt: number;
+    updatedAt: number;
+    metadata?: Record<string, unknown>;
+}
+interface SessionStore {
+    /** Load a session by ID. Returns null if not found or expired. */
+    get(sessionId: string): Promise<SessionData | null>;
+    /** Save or update a session. */
+    set(session: SessionData): Promise<void>;
+    /** Delete a session. */
+    delete(sessionId: string): Promise<void>;
+    /** Check if a session exists. */
+    exists(sessionId: string): Promise<boolean>;
+}
+declare class MemorySessionStore implements SessionStore {
+    private store;
+    private readonly ttlMs;
+    constructor(opts?: {
+        ttlMs?: number;
+    });
+    get(sessionId: string): Promise<SessionData | null>;
+    set(session: SessionData): Promise<void>;
+    delete(sessionId: string): Promise<void>;
+    exists(sessionId: string): Promise<boolean>;
+    /** For testing: number of active (non-expired) sessions. */
+    get size(): number;
+    private evictExpired;
+}
+
+/** Rough token count for a message array. */
+declare function estimateTokens(messages: Message[]): number;
+interface CompactOptions {
+    /** Max token budget for the conversation. Default 100_000. */
+    maxTokens?: number;
+    /** Number of recent messages to always keep uncompacted. Default 6. */
+    keepRecentCount?: number;
+    /** System prompt token estimate (subtracted from budget). Default 500. */
+    systemPromptTokens?: number;
+}
+/**
+ * Compact a conversation that exceeds the token budget.
+ *
+ * Strategy:
+ * 1. Always preserve the most recent `keepRecentCount` messages (the active context).
+ * 2. For older messages, summarise tool_result content to a brief one-liner.
+ * 3. If still over budget, drop the oldest messages (keeping the first user message
+ *    for context continuity).
+ *
+ * Returns a new array — does not mutate the input.
+ */
+declare function compactMessages(messages: readonly Message[], opts?: CompactOptions): Message[];
+
+interface McpToolDescriptor {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    handler: (args: Record<string, unknown>) => Promise<{
+        content: Array<{
+            type: 'text';
+            text: string;
+        }>;
+        isError?: boolean;
+    }>;
+}
+/**
+ * Builds MCP-compatible tool descriptors from engine tools.
+ * Each tool's `call()` is wrapped to return the MCP response format.
+ *
+ * Usage with @modelcontextprotocol/sdk:
+ * ```
+ * const descriptors = buildMcpTools(context);
+ * for (const desc of descriptors) {
+ *   server.tool(desc.name, desc.description, desc.inputSchema, desc.handler);
+ * }
+ * ```
+ */
+declare function buildMcpTools(context: ToolContext, tools?: Tool[]): McpToolDescriptor[];
+/**
+ * Register all engine tools with an MCP server instance.
+ * Convenience wrapper for the common pattern.
+ */
+declare function registerEngineTools(server: {
+    tool: (name: string, description: string, schema: Record<string, unknown>, handler: (args: Record<string, unknown>) => Promise<unknown>) => void;
+}, context: ToolContext, tools?: Tool[]): void;
+
+interface McpServerConfig {
+    /** Human-readable server name, used as tool namespace prefix. */
+    name: string;
+    /** MCP server URL (Streamable HTTP or SSE endpoint). */
+    url: string;
+    /** Transport type. Defaults to 'streamable-http'. */
+    transport?: 'streamable-http' | 'sse';
+    /** Response cache TTL in ms. Default 30_000 (30s). */
+    cacheTtlMs?: number;
+    /** Whether all tools from this server are read-only. Default true. */
+    readOnly?: boolean;
+}
+interface McpServerConnection {
+    config: McpServerConfig;
+    client: Client;
+    transport: Transport;
+    tools: Tool$1[];
+    status: 'connected' | 'disconnected' | 'error';
+    lastError?: string;
+}
+interface McpCallResult {
+    content: Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }>;
+    isError?: boolean;
+}
+declare class McpResponseCache {
+    private cache;
+    private readonly defaultTtlMs;
+    constructor(defaultTtlMs?: number);
+    private key;
+    get(serverName: string, toolName: string, args: unknown): McpCallResult | null;
+    set(serverName: string, toolName: string, args: unknown, result: McpCallResult, ttlMs?: number): void;
+    invalidate(serverName?: string): void;
+    get size(): number;
+}
+declare class McpClientManager {
+    private connections;
+    private readonly responseCache;
+    constructor(opts?: {
+        cacheTtlMs?: number;
+    });
+    /**
+     * Connect to an MCP server and discover its tools.
+     * If already connected to a server with this name, disconnects first.
+     */
+    connect(config: McpServerConfig): Promise<McpServerConnection>;
+    /** Disconnect from a server by name. */
+    disconnect(name: string): Promise<void>;
+    /** Disconnect from all servers. */
+    disconnectAll(): Promise<void>;
+    /** Get a connection by server name. */
+    getConnection(name: string): McpServerConnection | undefined;
+    /** Check if a server is connected. */
+    isConnected(name: string): boolean;
+    /** List all tool definitions across all connected servers. */
+    listAllTools(): Array<{
+        serverName: string;
+        tool: Tool$1;
+    }>;
+    /**
+     * Call a tool on a specific server.
+     * Uses response cache for read-only servers.
+     */
+    callTool(serverName: string, toolName: string, args?: Record<string, unknown>): Promise<McpCallResult>;
+    /** Get the response cache (for testing / manual invalidation). */
+    get cache(): McpResponseCache;
+    /** Number of connected servers. */
+    get serverCount(): number;
+    /** All server names. */
+    get serverNames(): string[];
+}
+
+interface McpToolAdapterConfig {
+    /** The McpClientManager to route calls through. */
+    manager: McpClientManager;
+    /** Server name this tool belongs to. */
+    serverName: string;
+    /** Override permission level for all tools from this server. */
+    permissionLevel?: PermissionLevel;
+    /** Override isReadOnly for all tools from this server. */
+    isReadOnly?: boolean;
+    /** Per-tool overrides keyed by MCP tool name. */
+    toolOverrides?: Record<string, {
+        permissionLevel?: PermissionLevel;
+        isReadOnly?: boolean;
+        description?: string;
+    }>;
+}
+/**
+ * Convert a single MCP tool definition into an engine Tool.
+ * The tool name is namespaced as `{serverName}_{mcpToolName}`.
+ */
+declare function adaptMcpTool(mcpTool: Tool$1, config: McpToolAdapterConfig): Tool;
+/**
+ * Convert all discovered tools from an MCP server into engine Tools.
+ * Call this after `manager.connect(config)` completes successfully.
+ */
+declare function adaptAllMcpTools(config: McpToolAdapterConfig): Tool[];
+/**
+ * Convenience: adapt tools from all connected servers.
+ * Returns a flat array of engine Tools, namespaced by server name.
+ */
+declare function adaptAllServerTools(manager: McpClientManager, serverConfigs?: Record<string, Omit<McpToolAdapterConfig, 'manager' | 'serverName'>>): Tool[];
+
+declare const NAVI_SERVER_NAME = "navi";
+declare const NAVI_MCP_URL = "https://open-api.naviprotocol.io/api/mcp";
+declare const NAVI_MCP_CONFIG: McpServerConfig;
+declare const NaviTools: {
+    readonly GET_POOLS: "navi_get_pools";
+    readonly GET_POOL: "navi_get_pool";
+    readonly GET_PROTOCOL_STATS: "navi_get_protocol_stats";
+    readonly GET_HEALTH_FACTOR: "navi_get_health_factor";
+    readonly GET_BORROW_FEE: "navi_get_borrow_fee";
+    readonly GET_FEES: "navi_get_fees";
+    readonly GET_FLASH_LOAN_ASSETS: "navi_get_flash_loan_assets";
+    readonly GET_FLASH_LOAN_ASSET: "navi_get_flash_loan_asset";
+    readonly GET_LENDING_REWARDS: "navi_get_lending_rewards";
+    readonly GET_AVAILABLE_REWARDS: "navi_get_available_rewards";
+    readonly GET_PRICE_FEEDS: "navi_get_price_feeds";
+    readonly GET_SWAP_QUOTE: "navi_get_swap_quote";
+    readonly GET_BRIDGE_CHAINS: "navi_get_bridge_chains";
+    readonly SEARCH_BRIDGE_TOKENS: "navi_search_bridge_tokens";
+    readonly GET_BRIDGE_QUOTE: "navi_get_bridge_quote";
+    readonly GET_BRIDGE_TX_STATUS: "navi_get_bridge_tx_status";
+    readonly GET_BRIDGE_HISTORY: "navi_get_bridge_history";
+    readonly GET_DCA_ORDERS: "navi_get_dca_orders";
+    readonly GET_DCA_ORDER_DETAILS: "navi_get_dca_order_details";
+    readonly LIST_DCA_ORDERS: "navi_list_dca_orders";
+    readonly GET_COINS: "navi_get_coins";
+    readonly GET_MARKET_CONFIG: "navi_get_market_config";
+    readonly GET_POSITIONS: "get_positions";
+    readonly GET_TRANSACTION: "sui_get_transaction";
+    readonly EXPLAIN_TRANSACTION: "sui_explain_transaction";
+    readonly SEARCH_TOKENS: "navi_search_tokens";
+};
+
+interface NaviRawPool {
+    id: number;
+    symbol: string;
+    coinType: string;
+    price: string;
+    market: string;
+    ltv: number;
+    liquidation: {
+        bonus: string;
+        ratio: string;
+        threshold: string;
+    };
+    supply: string;
+    borrow: string;
+    supplyApy: string;
+    borrowApy: string;
+}
+interface NaviRawPosition {
+    id: string;
+    protocol: string;
+    type: string;
+    market: string;
+    tokenASymbol: string;
+    tokenAPrice: number;
+    amountA: string;
+    tokenBSymbol?: string | null;
+    tokenBPrice?: number | null;
+    amountB?: string | null;
+    valueUSD: string;
+    apr: string;
+    liquidationThreshold: string;
+    lowerPrice?: string | null;
+    upperPrice?: string | null;
+    currentPrice?: string | null;
+    claimableRewards?: string | null;
+    isActive?: boolean;
+}
+interface NaviRawPositionsResponse {
+    address: string;
+    positions: NaviRawPosition[];
+}
+interface NaviRawHealthFactor {
+    address: string;
+    healthFactor: number | null;
+}
+interface NaviRawCoin {
+    coinType: string;
+    totalBalance: string;
+    coinObjectCount: number;
+    symbol?: string;
+    decimals?: number;
+}
+interface NaviRawRewardsResponse {
+    address: string;
+    rewards: Array<{
+        pool?: string;
+        rewardType?: string;
+        amount?: string;
+        symbol?: string;
+        valueUsd?: number;
+    }>;
+    summary: Array<{
+        symbol: string;
+        totalAmount: string;
+        valueUSD?: string;
+    }>;
+}
+interface NaviRawProtocolStats {
+    tvl: number;
+    totalBorrowUsd: number;
+    averageUtilization: number;
+    maxApy: number;
+    userAmount: number;
+    interactionUserAmount: number;
+    borrowFee: number;
+}
+interface RatesResult {
+    [symbol: string]: {
+        saveApy: number;
+        borrowApy: number;
+        ltv: number;
+        price: number;
+    };
+}
+interface HealthFactorResult {
+    healthFactor: number;
+    supplied: number;
+    borrowed: number;
+    maxBorrow: number;
+    liquidationThreshold: number;
+}
+interface BalanceResult {
+    available: number;
+    savings: number;
+    debt: number;
+    pendingRewards: number;
+    gasReserve: number;
+    total: number;
+    stables: number;
+}
+interface PositionEntry {
+    protocol: string;
+    type: 'supply' | 'borrow';
+    symbol: string;
+    amount: number;
+    valueUsd: number;
+    apy: number;
+    liquidationThreshold: number;
+}
+interface SavingsResult {
+    positions: PositionEntry[];
+    earnings: {
+        totalYieldEarned: number;
+        currentApy: number;
+        dailyEarning: number;
+        supplied: number;
+    };
+    fundStatus: {
+        supplied: number;
+        apy: number;
+        earnedToday: number;
+        earnedAllTime: number;
+        projectedMonthly: number;
+    };
+}
+declare function transformRates(raw: unknown): RatesResult;
+declare function transformPositions(raw: unknown): PositionEntry[];
+declare function transformHealthFactor(rawHf: unknown, rawPositions?: unknown): HealthFactorResult;
+interface PendingReward {
+    symbol: string;
+    totalAmount: number;
+    valueUsd: number;
+}
+declare function transformRewards(raw: unknown): PendingReward[];
+interface BalancePrices {
+    [symbol: string]: number;
+}
+declare function transformBalance(rawCoins: unknown, rawPositions: unknown, rawRewards: unknown, prices?: BalancePrices): BalanceResult;
+declare function transformSavings(rawPositions: unknown, rawPools: unknown): SavingsResult;
+declare function extractMcpText(content: Array<{
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+}>): string;
+declare function parseMcpJson<T = unknown>(content: Array<{
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+}>): T;
+
+interface NaviReadOptions {
+    /** MCP server name override (default: 'navi'). */
+    serverName?: string;
+}
+declare function fetchRates(manager: McpClientManager, opts?: NaviReadOptions): Promise<RatesResult>;
+declare function fetchHealthFactor(manager: McpClientManager, address: string, opts?: NaviReadOptions): Promise<HealthFactorResult>;
+declare function fetchBalance(manager: McpClientManager, address: string, opts?: NaviReadOptions): Promise<BalanceResult>;
+declare function fetchSavings(manager: McpClientManager, address: string, opts?: NaviReadOptions): Promise<SavingsResult>;
+declare function fetchPositions(manager: McpClientManager, address: string, opts?: NaviReadOptions & {
+    protocols?: string;
+}): Promise<PositionEntry[]>;
+declare function fetchAvailableRewards(manager: McpClientManager, address: string, opts?: NaviReadOptions): Promise<PendingReward[]>;
+interface ProtocolStats {
+    tvl: number;
+    totalBorrowUsd: number;
+    utilization: number;
+    maxApy: number;
+    totalUsers: number;
+}
+declare function fetchProtocolStats(manager: McpClientManager, opts?: NaviReadOptions): Promise<ProtocolStats>;
+
+interface AnthropicProviderConfig {
+    apiKey: string;
+    defaultModel?: string;
+    defaultMaxTokens?: number;
+}
+declare class AnthropicProvider implements LLMProvider {
+    private client;
+    private defaultModel;
+    private defaultMaxTokens;
+    constructor(config: AnthropicProviderConfig);
+    chat(params: ChatParams): AsyncGenerator<ProviderEvent>;
+}
+
+declare const balanceCheckTool: Tool<{}, BalanceResult>;
+
+declare const savingsInfoTool: Tool<{}, SavingsResult>;
+
+declare const healthCheckTool: Tool<{}, {
+    status: string;
+    healthFactor: number;
+    supplied: number;
+    borrowed: number;
+    maxBorrow: number;
+    liquidationThreshold: number;
+}>;
+
+declare const ratesInfoTool: Tool<{}, _t2000_sdk.RatesResult>;
+
+declare const transactionHistoryTool: Tool<{
+    limit?: number | undefined;
+}, {
+    transactions: _t2000_sdk.TransactionRecord[];
+    count: number;
+}>;
+
+declare const saveDepositTool: Tool<{
+    amount: number | "all";
+}, {
+    success: boolean;
+    tx: string;
+    amount: number;
+    apy: number;
+    fee: number;
+    gasCost: number;
+    savingsBalance: number;
+}>;
+
+declare const withdrawTool: Tool<{
+    amount: number | "all";
+}, {
+    success: boolean;
+    tx: string;
+    amount: number;
+    gasCost: number;
+}>;
+
+declare const sendTransferTool: Tool<{
+    amount: number;
+    to: string;
+}, {
+    success: boolean;
+    tx: string;
+    amount: number;
+    to: string;
+    contactName: string | undefined;
+    gasCost: number;
+    gasMethod: _t2000_sdk.GasMethod;
+    balance: _t2000_sdk.BalanceResponse;
+}>;
+
+declare const borrowTool: Tool<{
+    amount: number;
+}, {
+    success: boolean;
+    tx: string;
+    amount: number;
+    fee: number;
+    healthFactor: number;
+    gasCost: number;
+}>;
+
+declare const repayDebtTool: Tool<{
+    amount: number | "all";
+}, {
+    success: boolean;
+    tx: string;
+    amount: number;
+    remainingDebt: number;
+    gasCost: number;
+}>;
+
+declare const claimRewardsTool: Tool<{}, {
+    success: boolean;
+    tx: string | null;
+    rewards: _t2000_sdk.PendingReward[];
+    totalValueUsd: number;
+    gasCost: number;
+}>;
+
+declare const payApiTool: Tool<{
+    url: string;
+    method?: "GET" | "POST" | "PUT" | "DELETE" | undefined;
+    body?: string | undefined;
+    headers?: Record<string, string> | undefined;
+    maxPrice?: number | undefined;
+}, {
+    status: number;
+    body: unknown;
+    paid: boolean;
+    cost: number | undefined;
+    receipt: {
+        reference: string;
+        timestamp: string;
+    } | undefined;
+}>;
+
+declare const READ_TOOLS: Tool[];
+declare const WRITE_TOOLS: Tool[];
+declare function getDefaultTools(): Tool[];
+
+declare function requireAgent(context: ToolContext): T2000;
+/**
+ * Check if context has an MCP manager with a connected NAVI server
+ * and a wallet address for address-dependent reads.
+ */
+declare function hasNaviMcp(context: ToolContext): boolean;
+/**
+ * Get the MCP client manager from context (assumes hasNaviMcp() is true).
+ */
+declare function getMcpManager(context: ToolContext): McpClientManager;
+/**
+ * Get the wallet address from context (assumes hasNaviMcp() is true).
+ */
+declare function getWalletAddress(context: ToolContext): string;
+
+declare const DEFAULT_SYSTEM_PROMPT = "You are Audric, a financial agent operating on the Sui blockchain. You help users manage their USDC through savings, payments, transfers, and credit.\n\n## Capabilities\n- Check balances, savings positions, health factors, and interest rates\n- Execute deposits, withdrawals, transfers, borrows, and repayments\n- Access API services via micropayments (MPP)\n- Track transaction history and earnings\n\n## Guidelines\n\n### Before Acting\n- Always check the user's balance before suggesting financial actions\n- Show real numbers from tool results \u2014 never fabricate rates, amounts, or balances\n- For transactions that move funds, explain what will happen and confirm intent\n\n### Tool Usage\n- Use multiple read-only tools in parallel when you need several data points\n- Present amounts as currency ($1,234.56) and rates as percentages (4.86% APY)\n- If a tool errors, explain the issue clearly and suggest alternatives\n\n### Communication Style\n- Be concise and direct \u2014 users want financial data, not filler\n- Lead with numbers and results, follow with context\n- Use short sentences. Avoid hedging language.\n- When presenting positions or balances, use a structured format\n\n### Safety\n- Never encourage risky financial behavior\n- Warn when health factor drops below 1.5\n- Remind users of gas costs for on-chain transactions\n- All amounts are in USDC unless explicitly stated otherwise";
+
+export { AnthropicProvider, type AnthropicProviderConfig, type BalancePrices, type BalanceResult, type BuildToolOptions, type ChatParams, type CompactOptions, type ContentBlock, type CostSnapshot, CostTracker, type CostTrackerConfig, DEFAULT_SYSTEM_PROMPT, type EngineConfig, type EngineEvent, type HealthFactorResult, type LLMProvider, type McpCallResult, McpClientManager, McpResponseCache, type McpServerConfig, type McpServerConnection, type McpToolAdapterConfig, type McpToolDescriptor, MemorySessionStore, type Message, NAVI_MCP_CONFIG, NAVI_MCP_URL, NAVI_SERVER_NAME, type NaviRawCoin, type NaviRawHealthFactor, type NaviRawPool, type NaviRawPosition, type NaviRawPositionsResponse, type NaviRawProtocolStats, type NaviRawRewardsResponse, type NaviReadOptions, NaviTools, type PendingReward, type PendingToolCall, PermissionBridge, type PermissionLevel, type PositionEntry, type ProtocolStats, type ProviderEvent, QueryEngine, READ_TOOLS, type RatesResult, type SSEEvent, type SavingsResult, type SessionData, type SessionStore, type StopReason, type Tool, type ToolContext, type ToolDefinition, type ToolJsonSchema, type ToolResult, TxMutex, WRITE_TOOLS, adaptAllMcpTools, adaptAllServerTools, adaptMcpTool, balanceCheckTool, borrowTool, buildMcpTools, buildTool, claimRewardsTool, compactMessages, engineToSSE, estimateTokens, extractMcpText, fetchAvailableRewards, fetchBalance, fetchHealthFactor, fetchPositions, fetchProtocolStats, fetchRates, fetchSavings, findTool, getDefaultTools, getMcpManager, getWalletAddress, hasNaviMcp, healthCheckTool, parseMcpJson, parseSSE, payApiTool, ratesInfoTool, registerEngineTools, repayDebtTool, requireAgent, runTools, saveDepositTool, savingsInfoTool, sendTransferTool, serializeSSE, toolsToDefinitions, transactionHistoryTool, transformBalance, transformHealthFactor, transformPositions, transformRates, transformRewards, transformSavings, withdrawTool };