@t2000/engine 0.1.0

package/dist/index.js

@@ -0,0 +1,1901 @@
+import { z } from 'zod';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import Anthropic from '@anthropic-ai/sdk';
+
+// src/tool.ts
+function buildTool(opts) {
+  return {
+    name: opts.name,
+    description: opts.description,
+    inputSchema: opts.inputSchema,
+    jsonSchema: opts.jsonSchema,
+    call: opts.call,
+    isReadOnly: opts.isReadOnly ?? true,
+    isConcurrencySafe: opts.isReadOnly ?? true,
+    permissionLevel: opts.permissionLevel ?? (opts.isReadOnly === false ? "confirm" : "auto")
+  };
+}
+function toolsToDefinitions(tools) {
+  return tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    input_schema: t.jsonSchema
+  }));
+}
+function findTool(tools, name) {
+  return tools.find((t) => t.name === name);
+}
+
+// src/orchestration.ts
+var TxMutex = class {
+  queue = [];
+  locked = false;
+  async acquire() {
+    if (!this.locked) {
+      this.locked = true;
+      return;
+    }
+    return new Promise((resolve) => {
+      this.queue.push(resolve);
+    });
+  }
+  release() {
+    const next = this.queue.shift();
+    if (next) {
+      next();
+    } else {
+      this.locked = false;
+    }
+  }
+};
+async function* runTools(pending, tools, context, txMutex) {
+  const { reads, writes } = partitionToolCalls(pending, tools);
+  if (reads.length > 0) {
+    const readResults = await Promise.allSettled(
+      reads.map(async (call) => {
+        const tool = findTool(tools, call.name);
+        if (!tool) {
+          return { call, result: { data: { error: `Unknown tool: ${call.name}` } }, isError: true };
+        }
+        const execResult = await executeSingleTool(tool, call, context);
+        return { call, result: execResult, isError: execResult.isError };
+      })
+    );
+    for (const settled of readResults) {
+      if (settled.status === "fulfilled") {
+        const { call, result, isError } = settled.value;
+        yield {
+          type: "tool_result",
+          toolName: call.name,
+          toolUseId: call.id,
+          result: result.data,
+          isError
+        };
+      } else {
+        const idx = readResults.indexOf(settled);
+        const call = reads[idx];
+        yield {
+          type: "tool_result",
+          toolName: call.name,
+          toolUseId: call.id,
+          result: { error: settled.reason?.message ?? "Tool execution failed" },
+          isError: true
+        };
+      }
+    }
+  }
+  for (const call of writes) {
+    const tool = findTool(tools, call.name);
+    if (!tool) {
+      yield {
+        type: "tool_result",
+        toolName: call.name,
+        toolUseId: call.id,
+        result: { error: `Unknown tool: ${call.name}` },
+        isError: true
+      };
+      continue;
+    }
+    await txMutex.acquire();
+    try {
+      const result = await executeSingleTool(tool, call, context);
+      yield {
+        type: "tool_result",
+        toolName: call.name,
+        toolUseId: call.id,
+        result: result.data,
+        isError: result.isError
+      };
+    } catch (err) {
+      yield {
+        type: "tool_result",
+        toolName: call.name,
+        toolUseId: call.id,
+        result: { error: err instanceof Error ? err.message : "Tool execution failed" },
+        isError: true
+      };
+    } finally {
+      txMutex.release();
+    }
+  }
+}
+function partitionToolCalls(pending, tools) {
+  const reads = [];
+  const writes = [];
+  for (const call of pending) {
+    const tool = findTool(tools, call.name);
+    if (!tool) {
+      reads.push(call);
+      continue;
+    }
+    if (tool.isReadOnly && tool.isConcurrencySafe) {
+      reads.push(call);
+    } else {
+      writes.push(call);
+    }
+  }
+  return { reads, writes };
+}
+async function executeSingleTool(tool, call, context) {
+  const parsed = tool.inputSchema.safeParse(call.input);
+  if (!parsed.success) {
+    return {
+      data: {
+        error: `Invalid input: ${parsed.error.issues.map((i) => i.message).join(", ")}`
+      },
+      isError: true
+    };
+  }
+  const result = await tool.call(parsed.data, context);
+  return { data: result.data, isError: false };
+}
+
+// src/navi-config.ts
+var NAVI_SERVER_NAME = "navi";
+var NAVI_MCP_URL = "https://open-api.naviprotocol.io/api/mcp";
+var NAVI_MCP_CONFIG = {
+  name: NAVI_SERVER_NAME,
+  url: NAVI_MCP_URL,
+  transport: "streamable-http",
+  cacheTtlMs: 3e4,
+  readOnly: true
+};
+var NaviTools = {
+  GET_POOLS: "navi_get_pools",
+  GET_POOL: "navi_get_pool",
+  GET_PROTOCOL_STATS: "navi_get_protocol_stats",
+  GET_HEALTH_FACTOR: "navi_get_health_factor",
+  GET_BORROW_FEE: "navi_get_borrow_fee",
+  GET_FEES: "navi_get_fees",
+  GET_FLASH_LOAN_ASSETS: "navi_get_flash_loan_assets",
+  GET_FLASH_LOAN_ASSET: "navi_get_flash_loan_asset",
+  GET_LENDING_REWARDS: "navi_get_lending_rewards",
+  GET_AVAILABLE_REWARDS: "navi_get_available_rewards",
+  GET_PRICE_FEEDS: "navi_get_price_feeds",
+  GET_SWAP_QUOTE: "navi_get_swap_quote",
+  GET_BRIDGE_CHAINS: "navi_get_bridge_chains",
+  SEARCH_BRIDGE_TOKENS: "navi_search_bridge_tokens",
+  GET_BRIDGE_QUOTE: "navi_get_bridge_quote",
+  GET_BRIDGE_TX_STATUS: "navi_get_bridge_tx_status",
+  GET_BRIDGE_HISTORY: "navi_get_bridge_history",
+  GET_DCA_ORDERS: "navi_get_dca_orders",
+  GET_DCA_ORDER_DETAILS: "navi_get_dca_order_details",
+  LIST_DCA_ORDERS: "navi_list_dca_orders",
+  GET_COINS: "navi_get_coins",
+  GET_MARKET_CONFIG: "navi_get_market_config",
+  GET_POSITIONS: "get_positions",
+  GET_TRANSACTION: "sui_get_transaction",
+  EXPLAIN_TRANSACTION: "sui_explain_transaction",
+  SEARCH_TOKENS: "navi_search_tokens"
+};
+
+// src/navi-transforms.ts
+function toNum(v) {
+  if (v == null) return 0;
+  const n = typeof v === "number" ? v : Number(v);
+  return Number.isFinite(n) ? n : 0;
+}
+function transformRates(raw) {
+  const pools = Array.isArray(raw) ? raw : [];
+  const result = {};
+  for (const pool of pools) {
+    if (!pool.symbol) continue;
+    result[pool.symbol] = {
+      saveApy: toNum(pool.supplyApy) / 100,
+      borrowApy: toNum(pool.borrowApy) / 100,
+      ltv: toNum(pool.ltv),
+      price: toNum(pool.price)
+    };
+  }
+  return result;
+}
+function transformPositions(raw) {
+  const data = raw;
+  const positions = data?.positions ?? (Array.isArray(raw) ? raw : []);
+  return positions.map((p) => ({
+    protocol: p.protocol ?? "navi",
+    type: p.type?.includes("borrow") ? "borrow" : "supply",
+    symbol: p.tokenASymbol ?? "UNKNOWN",
+    amount: toNum(p.amountA),
+    valueUsd: toNum(p.valueUSD),
+    apy: toNum(p.apr) / 100,
+    liquidationThreshold: toNum(p.liquidationThreshold)
+  }));
+}
+function transformHealthFactor(rawHf, rawPositions) {
+  const hf = rawHf;
+  const positions = transformPositions(rawPositions);
+  const supplied = positions.filter((p) => p.type === "supply").reduce((sum, p) => sum + p.valueUsd, 0);
+  const borrowed = positions.filter((p) => p.type === "borrow").reduce((sum, p) => sum + p.valueUsd, 0);
+  const supplyPositions = positions.filter((p) => p.type === "supply");
+  const weightedLt = supplied > 0 ? supplyPositions.reduce(
+    (acc, p) => acc + p.liquidationThreshold * p.valueUsd,
+    0
+  ) / supplied : 0;
+  const maxBorrow = supplied * weightedLt - borrowed;
+  return {
+    healthFactor: toNum(hf?.healthFactor) || (borrowed === 0 ? Infinity : 0),
+    supplied,
+    borrowed,
+    maxBorrow: Math.max(0, maxBorrow),
+    liquidationThreshold: weightedLt
+  };
+}
+function transformRewards(raw) {
+  const data = raw;
+  return (data?.summary ?? []).map((s) => ({
+    symbol: s.symbol ?? "UNKNOWN",
+    totalAmount: toNum(s.totalAmount),
+    valueUsd: toNum(s.valueUSD)
+  }));
+}
+var STABLECOIN_SYMBOLS = /* @__PURE__ */ new Set([
+  "USDC",
+  "USDT",
+  "wUSDC",
+  "wUSDT",
+  "FDUSD",
+  "AUSD",
+  "BUCK",
+  "suiUSDe",
+  "USDSUI"
+]);
+var GAS_RESERVE_SUI = 0.05;
+function transformBalance(rawCoins, rawPositions, rawRewards, prices) {
+  const coins = Array.isArray(rawCoins) ? rawCoins : [];
+  const positions = transformPositions(rawPositions);
+  const rewards = transformRewards(rawRewards);
+  let availableUsd = 0;
+  let stablesUsd = 0;
+  let gasReserveUsd = 0;
+  for (const coin of coins) {
+    const symbol = coin.symbol ?? "";
+    const decimals = coin.decimals ?? (symbol === "SUI" ? 9 : 6);
+    const balance = toNum(coin.totalBalance) / 10 ** decimals;
+    const price = prices?.[symbol] ?? (STABLECOIN_SYMBOLS.has(symbol) ? 1 : 0);
+    if (symbol === "SUI" || coin.coinType === "0x2::sui::SUI") {
+      const reserveAmount = Math.min(balance, GAS_RESERVE_SUI);
+      gasReserveUsd = reserveAmount * price;
+      availableUsd += (balance - reserveAmount) * price;
+    } else {
+      availableUsd += balance * price;
+      if (STABLECOIN_SYMBOLS.has(symbol)) {
+        stablesUsd += balance * price;
+      }
+    }
+  }
+  const savings = positions.filter((p) => p.type === "supply").reduce((sum, p) => sum + p.valueUsd, 0);
+  const debt = positions.filter((p) => p.type === "borrow").reduce((sum, p) => sum + p.valueUsd, 0);
+  const pendingRewardsUsd = rewards.reduce((sum, r) => sum + r.valueUsd, 0);
+  return {
+    available: availableUsd,
+    savings,
+    debt,
+    pendingRewards: pendingRewardsUsd,
+    gasReserve: gasReserveUsd,
+    total: availableUsd + savings + gasReserveUsd + pendingRewardsUsd - debt,
+    stables: stablesUsd
+  };
+}
+function transformSavings(rawPositions, rawPools) {
+  const positions = transformPositions(rawPositions);
+  const rates = transformRates(rawPools);
+  const supplyPositions = positions.filter((p) => p.type === "supply");
+  const supplied = supplyPositions.reduce((sum, p) => sum + p.valueUsd, 0);
+  const weightedApy = supplied > 0 ? supplyPositions.reduce(
+    (acc, p) => acc + (rates[p.symbol]?.saveApy ?? p.apy) * p.valueUsd,
+    0
+  ) / supplied : 0;
+  const dailyEarning = supplied * weightedApy / 365;
+  const projectedMonthly = dailyEarning * 30;
+  return {
+    positions,
+    earnings: {
+      totalYieldEarned: 0,
+      // not available from MCP reads alone
+      currentApy: weightedApy,
+      dailyEarning,
+      supplied
+    },
+    fundStatus: {
+      supplied,
+      apy: weightedApy,
+      earnedToday: dailyEarning,
+      earnedAllTime: 0,
+      // not available from MCP reads alone
+      projectedMonthly
+    }
+  };
+}
+function extractMcpText(content) {
+  return content.filter((c) => c.type === "text" && c.text).map((c) => c.text).join("\n");
+}
+function parseMcpJson(content) {
+  const text = extractMcpText(content);
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
+// src/navi-reads.ts
+function sn(opts) {
+  return opts?.serverName ?? NAVI_SERVER_NAME;
+}
+async function callNavi(manager, tool, args = {}, opts) {
+  const result = await manager.callTool(sn(opts), tool, args);
+  if (result.isError) {
+    const msg = result.content.filter((c) => c.type === "text" && c.text).map((c) => c.text).join(" ");
+    throw new Error(`NAVI MCP error (${tool}): ${msg || "unknown error"}`);
+  }
+  return parseMcpJson(result.content);
+}
+async function fetchRates(manager, opts) {
+  const pools = await callNavi(manager, NaviTools.GET_POOLS, {}, opts);
+  return transformRates(pools);
+}
+async function fetchHealthFactor(manager, address, opts) {
+  const [hfRaw, posRaw] = await Promise.all([
+    callNavi(manager, NaviTools.GET_HEALTH_FACTOR, { address }, opts),
+    callNavi(manager, NaviTools.GET_POSITIONS, {
+      address,
+      protocols: "navi",
+      format: "json"
+    }, opts)
+  ]);
+  return transformHealthFactor(hfRaw, posRaw);
+}
+async function fetchBalance(manager, address, opts) {
+  const [coins, positions, rewards, pools] = await Promise.all([
+    callNavi(manager, NaviTools.GET_COINS, { address }, opts),
+    callNavi(manager, NaviTools.GET_POSITIONS, {
+      address,
+      protocols: "navi",
+      format: "json"
+    }, opts),
+    callNavi(manager, NaviTools.GET_AVAILABLE_REWARDS, { address }, opts),
+    callNavi(manager, NaviTools.GET_POOLS, {}, opts)
+  ]);
+  const rates = transformRates(pools);
+  const prices = {};
+  for (const [symbol, rate] of Object.entries(rates)) {
+    prices[symbol] = rate.price;
+  }
+  return transformBalance(coins, positions, rewards, prices);
+}
+async function fetchSavings(manager, address, opts) {
+  const [positions, pools] = await Promise.all([
+    callNavi(manager, NaviTools.GET_POSITIONS, {
+      address,
+      protocols: "navi",
+      format: "json"
+    }, opts),
+    callNavi(manager, NaviTools.GET_POOLS, {}, opts)
+  ]);
+  return transformSavings(positions, pools);
+}
+async function fetchPositions(manager, address, opts) {
+  const raw = await callNavi(
+    manager,
+    NaviTools.GET_POSITIONS,
+    { address, protocols: opts?.protocols ?? "navi", format: "json" },
+    opts
+  );
+  return transformPositions(raw);
+}
+async function fetchAvailableRewards(manager, address, opts) {
+  const raw = await callNavi(
+    manager,
+    NaviTools.GET_AVAILABLE_REWARDS,
+    { address },
+    opts
+  );
+  return transformRewards(raw);
+}
+async function fetchProtocolStats(manager, opts) {
+  const raw = await callNavi(manager, NaviTools.GET_PROTOCOL_STATS, {}, opts);
+  return {
+    tvl: raw?.tvl ?? 0,
+    totalBorrowUsd: raw?.totalBorrowUsd ?? 0,
+    utilization: raw?.averageUtilization ?? 0,
+    maxApy: raw?.maxApy ?? 0,
+    totalUsers: raw?.userAmount ?? 0
+  };
+}
+
+// src/tools/utils.ts
+function requireAgent(context) {
+  if (!context.agent) {
+    throw new Error(
+      "Tool requires a T2000 agent instance \u2014 pass `agent` in EngineConfig"
+    );
+  }
+  return context.agent;
+}
+function hasNaviMcp(context) {
+  if (!context.mcpManager || !context.walletAddress) return false;
+  const mgr = context.mcpManager;
+  return mgr.isConnected(NAVI_SERVER_NAME);
+}
+function getMcpManager(context) {
+  return context.mcpManager;
+}
+function getWalletAddress(context) {
+  return context.walletAddress;
+}
+
+// src/tools/balance.ts
+var balanceCheckTool = buildTool({
+  name: "balance_check",
+  description: "Get the user's full balance breakdown: available USDC, savings deposits, outstanding debt, pending rewards, gas reserve, and total net worth.",
+  inputSchema: z.object({}),
+  jsonSchema: { type: "object", properties: {}, required: [] },
+  isReadOnly: true,
+  async call(_input, context) {
+    if (hasNaviMcp(context)) {
+      const bal = await fetchBalance(
+        getMcpManager(context),
+        getWalletAddress(context)
+      );
+      return {
+        data: bal,
+        displayText: `Balance: $${bal.total.toFixed(2)} (Available: $${bal.available.toFixed(2)}, Savings: $${bal.savings.toFixed(2)})`
+      };
+    }
+    const agent = requireAgent(context);
+    const balance = await agent.balance();
+    const gasReserveUsd = typeof balance.gasReserve === "number" ? balance.gasReserve : balance.gasReserve.usdEquiv ?? 0;
+    const stablesTotal = typeof balance.stables === "number" ? balance.stables : Object.values(balance.stables).reduce((a, b) => a + b, 0);
+    return {
+      data: {
+        available: balance.available,
+        savings: balance.savings,
+        debt: balance.debt,
+        pendingRewards: balance.pendingRewards,
+        gasReserve: gasReserveUsd,
+        total: balance.total,
+        stables: stablesTotal
+      },
+      displayText: `Balance: $${balance.total.toFixed(2)} (Available: $${balance.available.toFixed(2)}, Savings: $${balance.savings.toFixed(2)})`
+    };
+  }
+});
+var savingsInfoTool = buildTool({
+  name: "savings_info",
+  description: "Get detailed savings positions and earnings: current deposits by protocol, APY, total yield earned, daily earning rate, and projected monthly returns.",
+  inputSchema: z.object({}),
+  jsonSchema: { type: "object", properties: {}, required: [] },
+  isReadOnly: true,
+  async call(_input, context) {
+    if (hasNaviMcp(context)) {
+      const savings = await fetchSavings(
+        getMcpManager(context),
+        getWalletAddress(context)
+      );
+      return { data: savings };
+    }
+    const agent = requireAgent(context);
+    const [posResult, earnings, fundStatus] = await Promise.all([
+      agent.positions(),
+      agent.earnings(),
+      agent.fundStatus()
+    ]);
+    const positions = (posResult.positions ?? []).map((p) => ({
+      protocol: p.protocol ?? "navi",
+      type: p.type === "borrow" ? "borrow" : "supply",
+      symbol: p.asset ?? p.symbol ?? "UNKNOWN",
+      amount: p.amount ?? 0,
+      valueUsd: p.amountUsd ?? p.valueUsd ?? 0,
+      apy: p.apy ?? 0,
+      liquidationThreshold: p.liquidationThreshold ?? 0
+    }));
+    return {
+      data: {
+        positions,
+        earnings: {
+          totalYieldEarned: earnings.totalYieldEarned,
+          currentApy: earnings.currentApy,
+          dailyEarning: earnings.dailyEarning,
+          supplied: earnings.supplied
+        },
+        fundStatus: {
+          supplied: fundStatus.supplied,
+          apy: fundStatus.apy,
+          earnedToday: fundStatus.earnedToday,
+          earnedAllTime: fundStatus.earnedAllTime,
+          projectedMonthly: fundStatus.projectedMonthly
+        }
+      }
+    };
+  }
+});
+function hfStatus(hf) {
+  if (hf >= 2) return "healthy";
+  if (hf >= 1.5) return "moderate";
+  if (hf >= 1.2) return "warning";
+  return "critical";
+}
+var healthCheckTool = buildTool({
+  name: "health_check",
+  description: "Check the lending health factor: current HF ratio, total supplied collateral, total borrowed, max additional borrow capacity, and liquidation threshold. HF < 1.5 is risky, < 1.2 is critical.",
+  inputSchema: z.object({}),
+  jsonSchema: { type: "object", properties: {}, required: [] },
+  isReadOnly: true,
+  async call(_input, context) {
+    if (hasNaviMcp(context)) {
+      const hf2 = await fetchHealthFactor(
+        getMcpManager(context),
+        getWalletAddress(context)
+      );
+      const status2 = hfStatus(hf2.healthFactor);
+      const displayHf = Number.isFinite(hf2.healthFactor) ? hf2.healthFactor.toFixed(2) : "\u221E";
+      return {
+        data: { ...hf2, status: status2 },
+        displayText: `Health Factor: ${displayHf} (${status2})`
+      };
+    }
+    const agent = requireAgent(context);
+    const hf = await agent.healthFactor();
+    const status = hfStatus(hf.healthFactor);
+    return {
+      data: {
+        healthFactor: hf.healthFactor,
+        supplied: hf.supplied,
+        borrowed: hf.borrowed,
+        maxBorrow: hf.maxBorrow,
+        liquidationThreshold: hf.liquidationThreshold,
+        status
+      },
+      displayText: `Health Factor: ${hf.healthFactor.toFixed(2)} (${status})`
+    };
+  }
+});
+function formatRatesSummary(rates) {
+  return Object.entries(rates).map(([asset, r]) => `${asset}: Save ${(r.saveApy * 100).toFixed(2)}% / Borrow ${(r.borrowApy * 100).toFixed(2)}%`).join(", ");
+}
+var ratesInfoTool = buildTool({
+  name: "rates_info",
+  description: "Get current lending/borrowing interest rates (APY) for all supported assets. Returns save APY and borrow APY per asset.",
+  inputSchema: z.object({}),
+  jsonSchema: { type: "object", properties: {}, required: [] },
+  isReadOnly: true,
+  async call(_input, context) {
+    if (hasNaviMcp(context)) {
+      const rates2 = await fetchRates(getMcpManager(context));
+      return {
+        data: rates2,
+        displayText: formatRatesSummary(rates2)
+      };
+    }
+    const agent = requireAgent(context);
+    const rates = await agent.rates();
+    return {
+      data: rates,
+      displayText: formatRatesSummary(rates)
+    };
+  }
+});
+var transactionHistoryTool = buildTool({
+  name: "transaction_history",
+  description: "Retrieve recent transaction history: past sends, saves, withdrawals, borrows, repayments, and rewards claims. Optionally limit the number of results.",
+  inputSchema: z.object({
+    limit: z.number().int().min(1).max(50).optional()
+  }),
+  jsonSchema: {
+    type: "object",
+    properties: {
+      limit: {
+        type: "number",
+        description: "Maximum number of transactions to return (1-50, default 10)"
+      }
+    }
+  },
+  isReadOnly: true,
+  async call(input, context) {
+    const agent = requireAgent(context);
+    const records = await agent.history({ limit: input.limit ?? 10 });
+    return {
+      data: {
+        transactions: records,
+        count: records.length
+      },
+      displayText: `${records.length} recent transaction(s)`
+    };
+  }
+});
+var saveDepositTool = buildTool({
+  name: "save_deposit",
+  description: 'Deposit USDC into savings to earn yield. Specify an amount in USD or "all" to save everything except a $1 gas reserve. Returns tx hash, APY, fee, and updated savings balance.',
+  inputSchema: z.object({
+    amount: z.union([z.number().positive(), z.literal("all")])
+  }),
+  jsonSchema: {
+    type: "object",
+    properties: {
+      amount: {
+        description: 'Amount in USD to save, or "all" for maximum deposit'
+      }
+    },
+    required: ["amount"]
+  },
+  isReadOnly: false,
+  permissionLevel: "confirm",
+  async call(input, context) {
+    const agent = requireAgent(context);
+    const result = await agent.save({ amount: input.amount });
+    return {
+      data: {
+        success: result.success,
+        tx: result.tx,
+        amount: result.amount,
+        apy: result.apy,
+        fee: result.fee,
+        gasCost: result.gasCost,
+        savingsBalance: result.savingsBalance
+      },
+      displayText: `Saved $${result.amount.toFixed(2)} at ${(result.apy * 100).toFixed(2)}% APY (tx: ${result.tx.slice(0, 8)}\u2026)`
+    };
+  }
+});
+var withdrawTool = buildTool({
+  name: "withdraw",
+  description: 'Withdraw USDC from savings back to wallet. Specify an amount in USD or "all" to withdraw everything safely. Checks health factor to prevent liquidation if there is outstanding debt.',
+  inputSchema: z.object({
+    amount: z.union([z.number().positive(), z.literal("all")])
+  }),
+  jsonSchema: {
+    type: "object",
+    properties: {
+      amount: {
+        description: 'Amount in USD to withdraw, or "all" for full withdrawal'
+      }
+    },
+    required: ["amount"]
+  },
+  isReadOnly: false,
+  permissionLevel: "confirm",
+  async call(input, context) {
+    const agent = requireAgent(context);
+    const result = await agent.withdraw({ amount: input.amount });
+    return {
+      data: {
+        success: result.success,
+        tx: result.tx,
+        amount: result.amount,
+        gasCost: result.gasCost
+      },
+      displayText: `Withdrew $${result.amount.toFixed(2)} (tx: ${result.tx.slice(0, 8)}\u2026)`
+    };
+  }
+});
+var sendTransferTool = buildTool({
+  name: "send_transfer",
+  description: "Send USDC to another Sui address or contact name. Validates the address, checks balance, and executes the on-chain transfer. Returns tx hash, gas cost, and updated balance.",
+  inputSchema: z.object({
+    to: z.string().min(1),
+    amount: z.number().positive()
+  }),
+  jsonSchema: {
+    type: "object",
+    properties: {
+      to: {
+        type: "string",
+        description: "Sui address (0x\u2026) or saved contact name"
+      },
+      amount: {
+        type: "number",
+        description: "Amount in USD to send"
+      }
+    },
+    required: ["to", "amount"]
+  },
+  isReadOnly: false,
+  permissionLevel: "confirm",
+  async call(input, context) {
+    const agent = requireAgent(context);
+    const result = await agent.send({ to: input.to, amount: input.amount });
+    return {
+      data: {
+        success: result.success,
+        tx: result.tx,
+        amount: result.amount,
+        to: result.to,
+        contactName: result.contactName,
+        gasCost: result.gasCost,
+        gasMethod: result.gasMethod,
+        balance: result.balance
+      },
+      displayText: `Sent $${result.amount.toFixed(2)} to ${result.contactName ?? result.to.slice(0, 10)}\u2026 (tx: ${result.tx.slice(0, 8)}\u2026)`
+    };
+  }
+});
+var borrowTool = buildTool({
+  name: "borrow",
+  description: "Borrow USDC against savings collateral. Requires existing savings deposits. Checks max safe borrow and health factor. Returns tx hash, fee, and post-borrow health factor.",
+  inputSchema: z.object({
+    amount: z.number().positive()
+  }),
+  jsonSchema: {
+    type: "object",
+    properties: {
+      amount: {
+        type: "number",
+        description: "Amount in USD to borrow"
+      }
+    },
+    required: ["amount"]
+  },
+  isReadOnly: false,
+  permissionLevel: "confirm",
+  async call(input, context) {
+    const agent = requireAgent(context);
+    const result = await agent.borrow({ amount: input.amount });
+    return {
+      data: {
+        success: result.success,
+        tx: result.tx,
+        amount: result.amount,
+        fee: result.fee,
+        healthFactor: result.healthFactor,
+        gasCost: result.gasCost
+      },
+      displayText: `Borrowed $${result.amount.toFixed(2)} \u2014 HF: ${result.healthFactor.toFixed(2)} (tx: ${result.tx.slice(0, 8)}\u2026)`
+    };
+  }
+});
+var repayDebtTool = buildTool({
+  name: "repay_debt",
+  description: 'Repay outstanding USDC debt. Specify an amount or "all" to repay everything. Prioritises the highest-APY borrow first. Returns tx hash, amount repaid, and remaining debt.',
+  inputSchema: z.object({
+    amount: z.union([z.number().positive(), z.literal("all")])
+  }),
+  jsonSchema: {
+    type: "object",
+    properties: {
+      amount: {
+        description: 'Amount in USD to repay, or "all" to repay everything'
+      }
+    },
+    required: ["amount"]
+  },
+  isReadOnly: false,
+  permissionLevel: "confirm",
+  async call(input, context) {
+    const agent = requireAgent(context);
+    const result = await agent.repay({ amount: input.amount });
+    return {
+      data: {
+        success: result.success,
+        tx: result.tx,
+        amount: result.amount,
+        remainingDebt: result.remainingDebt,
+        gasCost: result.gasCost
+      },
+      displayText: `Repaid $${result.amount.toFixed(2)} \u2014 remaining debt: $${result.remainingDebt.toFixed(2)} (tx: ${result.tx.slice(0, 8)}\u2026)`
+    };
+  }
+});
+var claimRewardsTool = buildTool({
+  name: "claim_rewards",
+  description: "Claim all pending protocol rewards across lending adapters. Returns claimed reward details and total USD value.",
+  inputSchema: z.object({}),
+  jsonSchema: { type: "object", properties: {}, required: [] },
+  isReadOnly: false,
+  permissionLevel: "confirm",
+  async call(_input, context) {
+    const agent = requireAgent(context);
+    const result = await agent.claimRewards();
+    return {
+      data: {
+        success: result.success,
+        tx: result.tx || null,
+        rewards: result.rewards,
+        totalValueUsd: result.totalValueUsd,
+        gasCost: result.gasCost
+      },
+      displayText: result.rewards.length === 0 ? "No pending rewards to claim." : `Claimed $${result.totalValueUsd.toFixed(2)} in rewards (tx: ${result.tx.slice(0, 8)}\u2026)`
+    };
+  }
+});
+var payApiTool = buildTool({
+  name: "pay_api",
+  description: "Access a paid API endpoint using on-chain micropayments (MPP). Sends the request, handles payment automatically, and returns the API response body. Use for accessing premium data services.",
+  inputSchema: z.object({
+    url: z.string().url(),
+    method: z.enum(["GET", "POST", "PUT", "DELETE"]).optional(),
+    body: z.string().optional(),
+    headers: z.record(z.string()).optional(),
+    maxPrice: z.number().positive().optional()
+  }),
+  jsonSchema: {
+    type: "object",
+    properties: {
+      url: { type: "string", description: "API endpoint URL" },
+      method: { type: "string", description: "HTTP method (default GET)" },
+      body: { type: "string", description: "Request body (for POST/PUT)" },
+      headers: { type: "object", description: "Additional HTTP headers" },
+      maxPrice: { type: "number", description: "Maximum price in USD willing to pay" }
+    },
+    required: ["url"]
+  },
+  isReadOnly: false,
+  permissionLevel: "confirm",
+  async call(input, context) {
+    const agent = requireAgent(context);
+    const result = await agent.pay({
+      url: input.url,
+      method: input.method,
+      body: input.body,
+      headers: input.headers,
+      maxPrice: input.maxPrice
+    });
+    return {
+      data: {
+        status: result.status,
+        body: result.body,
+        paid: result.paid,
+        cost: result.cost,
+        receipt: result.receipt
+      },
+      displayText: result.paid ? `API call completed \u2014 paid $${result.cost?.toFixed(4) ?? "?"} (status: ${result.status})` : `API call completed \u2014 free (status: ${result.status})`
+    };
+  }
+});
+
+// src/tools/index.ts
+var READ_TOOLS = [
+  balanceCheckTool,
+  savingsInfoTool,
+  healthCheckTool,
+  ratesInfoTool,
+  transactionHistoryTool
+];
+var WRITE_TOOLS = [
+  saveDepositTool,
+  withdrawTool,
+  sendTransferTool,
+  borrowTool,
+  repayDebtTool,
+  claimRewardsTool,
+  payApiTool
+];
+function getDefaultTools() {
+  return [...READ_TOOLS, ...WRITE_TOOLS];
+}
+
+// src/prompt.ts
+var 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.
+
+## Capabilities
+- Check balances, savings positions, health factors, and interest rates
+- Execute deposits, withdrawals, transfers, borrows, and repayments
+- Access API services via micropayments (MPP)
+- Track transaction history and earnings
+
+## Guidelines
+
+### Before Acting
+- Always check the user's balance before suggesting financial actions
+- Show real numbers from tool results \u2014 never fabricate rates, amounts, or balances
+- For transactions that move funds, explain what will happen and confirm intent
+
+### Tool Usage
+- Use multiple read-only tools in parallel when you need several data points
+- Present amounts as currency ($1,234.56) and rates as percentages (4.86% APY)
+- If a tool errors, explain the issue clearly and suggest alternatives
+
+### Communication Style
+- Be concise and direct \u2014 users want financial data, not filler
+- Lead with numbers and results, follow with context
+- Use short sentences. Avoid hedging language.
+- When presenting positions or balances, use a structured format
+
+### Safety
+- Never encourage risky financial behavior
+- Warn when health factor drops below 1.5
+- Remind users of gas costs for on-chain transactions
+- All amounts are in USDC unless explicitly stated otherwise`;
+
+// src/cost.ts
+var DEFAULT_INPUT_COST = 3 / 1e6;
+var DEFAULT_OUTPUT_COST = 15 / 1e6;
+var CACHE_WRITE_MULTIPLIER = 1.25;
+var CACHE_READ_MULTIPLIER = 0.1;
+var CostTracker = class {
+  inputTokens = 0;
+  outputTokens = 0;
+  cacheReadTokens = 0;
+  cacheWriteTokens = 0;
+  budgetLimitUsd;
+  inputCost;
+  outputCost;
+  constructor(config = {}) {
+    this.budgetLimitUsd = config.budgetLimitUsd ?? null;
+    this.inputCost = config.inputCostPerToken ?? DEFAULT_INPUT_COST;
+    this.outputCost = config.outputCostPerToken ?? DEFAULT_OUTPUT_COST;
+  }
+  track(inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens) {
+    this.inputTokens += inputTokens;
+    this.outputTokens += outputTokens;
+    this.cacheReadTokens += cacheReadTokens ?? 0;
+    this.cacheWriteTokens += cacheWriteTokens ?? 0;
+  }
+  getSnapshot() {
+    const totalTokens = this.inputTokens + this.outputTokens + this.cacheReadTokens + this.cacheWriteTokens;
+    const estimatedCostUsd = this.inputTokens * this.inputCost + this.outputTokens * this.outputCost + this.cacheReadTokens * this.inputCost * CACHE_READ_MULTIPLIER + this.cacheWriteTokens * this.inputCost * CACHE_WRITE_MULTIPLIER;
+    return {
+      inputTokens: this.inputTokens,
+      outputTokens: this.outputTokens,
+      cacheReadTokens: this.cacheReadTokens,
+      cacheWriteTokens: this.cacheWriteTokens,
+      totalTokens,
+      estimatedCostUsd
+    };
+  }
+  isOverBudget() {
+    if (this.budgetLimitUsd === null) return false;
+    return this.getSnapshot().estimatedCostUsd >= this.budgetLimitUsd;
+  }
+  getRemainingBudgetUsd() {
+    if (this.budgetLimitUsd === null) return null;
+    return Math.max(0, this.budgetLimitUsd - this.getSnapshot().estimatedCostUsd);
+  }
+  reset() {
+    this.inputTokens = 0;
+    this.outputTokens = 0;
+    this.cacheReadTokens = 0;
+    this.cacheWriteTokens = 0;
+  }
+};
+
+// src/engine.ts
+var DEFAULT_MAX_TURNS = 10;
+var DEFAULT_MAX_TOKENS = 4096;
+var QueryEngine = class {
+  provider;
+  tools;
+  systemPrompt;
+  model;
+  maxTurns;
+  maxTokens;
+  agent;
+  mcpManager;
+  walletAddress;
+  txMutex = new TxMutex();
+  costTracker;
+  messages = [];
+  abortController = null;
+  constructor(config) {
+    this.provider = config.provider;
+    this.agent = config.agent;
+    this.mcpManager = config.mcpManager;
+    this.walletAddress = config.walletAddress;
+    this.model = config.model;
+    this.maxTurns = config.maxTurns ?? DEFAULT_MAX_TURNS;
+    this.maxTokens = config.maxTokens ?? DEFAULT_MAX_TOKENS;
+    this.systemPrompt = config.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+    this.costTracker = new CostTracker(config.costTracker);
+    this.tools = config.tools ?? (config.agent ? getDefaultTools() : []);
+  }
+  /**
+   * Submit a user message and receive a stream of engine events.
+   * Handles the full agent loop: LLM → permission check → tool execution → LLM → ...
+   */
+  async *submitMessage(prompt) {
+    if (this.costTracker.isOverBudget()) {
+      yield { type: "error", error: new Error("Session budget exceeded") };
+      return;
+    }
+    this.abortController = new AbortController();
+    const signal = this.abortController.signal;
+    this.messages.push({
+      role: "user",
+      content: [{ type: "text", text: prompt }]
+    });
+    const context = {
+      agent: this.agent,
+      mcpManager: this.mcpManager,
+      walletAddress: this.walletAddress,
+      signal
+    };
+    let turns = 0;
+    while (turns < this.maxTurns) {
+      if (signal.aborted) {
+        yield { type: "error", error: new Error("Aborted") };
+        return;
+      }
+      turns++;
+      const toolDefs = toolsToDefinitions(this.tools);
+      const acc = {
+        text: "",
+        stopReason: "end_turn",
+        assistantBlocks: [],
+        pendingToolCalls: []
+      };
+      const stream = this.provider.chat({
+        messages: this.messages,
+        systemPrompt: this.systemPrompt,
+        tools: toolDefs,
+        model: this.model,
+        maxTokens: this.maxTokens,
+        signal
+      });
+      for await (const event of stream) {
+        yield* this.handleProviderEvent(event, acc);
+      }
+      if (acc.text) {
+        acc.assistantBlocks.push({ type: "text", text: acc.text });
+      }
+      this.messages.push({ role: "assistant", content: acc.assistantBlocks });
+      if (acc.pendingToolCalls.length === 0) {
+        yield { type: "turn_complete", stopReason: acc.stopReason };
+        return;
+      }
+      if (signal.aborted) {
+        yield { type: "error", error: new Error("Aborted") };
+        return;
+      }
+      const approved = [];
+      const toolResultBlocks = [];
+      for (const call of acc.pendingToolCalls) {
+        const tool = findTool(this.tools, call.name);
+        const needsConfirmation = tool && !tool.isReadOnly && tool.permissionLevel !== "auto";
+        if (!needsConfirmation) {
+          approved.push(call);
+          yield { type: "tool_start", toolName: call.name, toolUseId: call.id, input: call.input };
+          continue;
+        }
+        let resolvePermission;
+        const permissionPromise = new Promise((r) => {
+          resolvePermission = r;
+        });
+        yield {
+          type: "permission_request",
+          toolName: call.name,
+          toolUseId: call.id,
+          input: call.input,
+          description: describeAction(tool, call),
+          resolve: resolvePermission
+        };
+        let userApproved;
+        try {
+          userApproved = await Promise.race([
+            permissionPromise,
+            new Promise((_, reject) => {
+              if (signal.aborted) reject(new Error("Aborted"));
+              signal.addEventListener("abort", () => reject(new Error("Aborted")), { once: true });
+            })
+          ]);
+        } catch {
+          yield { type: "error", error: new Error("Aborted") };
+          return;
+        }
+        if (userApproved) {
+          approved.push(call);
+          yield { type: "tool_start", toolName: call.name, toolUseId: call.id, input: call.input };
+        } else {
+          toolResultBlocks.push({
+            type: "tool_result",
+            toolUseId: call.id,
+            content: JSON.stringify({ error: "User declined this action" }),
+            isError: true
+          });
+          yield {
+            type: "tool_result",
+            toolName: call.name,
+            toolUseId: call.id,
+            result: { error: "User declined this action" },
+            isError: true
+          };
+        }
+      }
+      for await (const toolEvent of runTools(approved, this.tools, context, this.txMutex)) {
+        yield toolEvent;
+        if (toolEvent.type === "tool_result") {
+          toolResultBlocks.push({
+            type: "tool_result",
+            toolUseId: toolEvent.toolUseId,
+            content: JSON.stringify(toolEvent.result),
+            isError: toolEvent.isError
+          });
+        }
+      }
+      this.messages.push({ role: "user", content: toolResultBlocks });
+      if (this.costTracker.isOverBudget()) {
+        yield { type: "error", error: new Error("Session budget exceeded") };
+        return;
+      }
+    }
+    yield { type: "turn_complete", stopReason: "max_turns" };
+  }
+  interrupt() {
+    this.abortController?.abort();
+  }
+  getMessages() {
+    return this.messages;
+  }
+  reset() {
+    this.messages = [];
+    this.costTracker.reset();
+  }
+  loadMessages(messages) {
+    this.messages = [...messages];
+  }
+  getUsage() {
+    return this.costTracker.getSnapshot();
+  }
+  // ---------------------------------------------------------------------------
+  // Internal
+  // ---------------------------------------------------------------------------
+  *handleProviderEvent(event, acc) {
+    switch (event.type) {
+      case "text_delta": {
+        acc.text += event.text;
+        yield { type: "text_delta", text: event.text };
+        break;
+      }
+      case "tool_use_done": {
+        acc.assistantBlocks.push({
+          type: "tool_use",
+          id: event.id,
+          name: event.name,
+          input: event.input
+        });
+        acc.pendingToolCalls.push({
+          id: event.id,
+          name: event.name,
+          input: event.input
+        });
+        break;
+      }
+      case "usage": {
+        this.costTracker.track(
+          event.inputTokens,
+          event.outputTokens,
+          event.cacheReadTokens,
+          event.cacheWriteTokens
+        );
+        yield {
+          type: "usage",
+          inputTokens: event.inputTokens,
+          outputTokens: event.outputTokens,
+          cacheReadTokens: event.cacheReadTokens,
+          cacheWriteTokens: event.cacheWriteTokens
+        };
+        break;
+      }
+      case "stop": {
+        acc.stopReason = event.reason;
+        break;
+      }
+    }
+  }
+};
+function describeAction(tool, call) {
+  const input = call.input;
+  switch (tool.name) {
+    case "save_deposit":
+      return `Save ${input.amount === "all" ? "all available" : `$${input.amount}`} into savings`;
+    case "withdraw":
+      return `Withdraw ${input.amount === "all" ? "all" : `$${input.amount}`} from savings`;
+    case "send_transfer":
+      return `Send $${input.amount} to ${input.to}`;
+    case "borrow":
+      return `Borrow $${input.amount} against collateral`;
+    case "repay_debt":
+      return `Repay ${input.amount === "all" ? "all" : `$${input.amount}`} of outstanding debt`;
+    case "claim_rewards":
+      return "Claim all pending protocol rewards";
+    case "pay_api":
+      return `Pay for API call to ${input.url}${input.maxPrice ? ` (max $${input.maxPrice})` : ""}`;
+    default:
+      return `Execute ${tool.name}`;
+  }
+}
+
+// src/streaming.ts
+function serializeSSE(event) {
+  const data = JSON.stringify(event);
+  return `event: ${event.type}
+data: ${data}
+
+`;
+}
+function parseSSE(raw) {
+  const dataLine = raw.split("\n").find((l) => l.startsWith("data: "));
+  if (!dataLine) return null;
+  try {
+    return JSON.parse(dataLine.slice(6));
+  } catch {
+    return null;
+  }
+}
+var PermissionBridge = class {
+  pending = /* @__PURE__ */ new Map();
+  counter = 0;
+  /**
+   * Register a permission_request resolve callback.
+   * Returns the permissionId to send to the client.
+   */
+  register(resolve) {
+    const id = `perm_${++this.counter}_${Date.now()}`;
+    this.pending.set(id, resolve);
+    return id;
+  }
+  /**
+   * Resolve a pending permission request from the client.
+   * Returns false if the permissionId is unknown (expired or invalid).
+   */
+  resolve(permissionId, approved) {
+    const resolver = this.pending.get(permissionId);
+    if (!resolver) return false;
+    resolver(approved);
+    this.pending.delete(permissionId);
+    return true;
+  }
+  /** Number of pending (unresolved) permission requests. */
+  get size() {
+    return this.pending.size;
+  }
+  /** Reject all pending permissions (e.g., on disconnect). */
+  rejectAll() {
+    for (const resolver of this.pending.values()) {
+      resolver(false);
+    }
+    this.pending.clear();
+  }
+};
+async function* engineToSSE(events, bridge) {
+  for await (const event of events) {
+    switch (event.type) {
+      case "permission_request": {
+        const permissionId = bridge.register(event.resolve);
+        yield serializeSSE({
+          type: "permission_request",
+          permissionId,
+          toolName: event.toolName,
+          toolUseId: event.toolUseId,
+          input: event.input,
+          description: event.description
+        });
+        break;
+      }
+      case "error": {
+        yield serializeSSE({
+          type: "error",
+          message: event.error.message
+        });
+        break;
+      }
+      default: {
+        yield serializeSSE(event);
+        break;
+      }
+    }
+  }
+}
+
+// src/session.ts
+var MemorySessionStore = class {
+  store = /* @__PURE__ */ new Map();
+  ttlMs;
+  constructor(opts) {
+    this.ttlMs = opts?.ttlMs ?? 24 * 60 * 60 * 1e3;
+  }
+  async get(sessionId) {
+    const entry = this.store.get(sessionId);
+    if (!entry) return null;
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(sessionId);
+      return null;
+    }
+    return structuredClone(entry.data);
+  }
+  async set(session) {
+    this.store.set(session.id, {
+      data: structuredClone(session),
+      expiresAt: Date.now() + this.ttlMs
+    });
+  }
+  async delete(sessionId) {
+    this.store.delete(sessionId);
+  }
+  async exists(sessionId) {
+    const entry = this.store.get(sessionId);
+    if (!entry) return false;
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(sessionId);
+      return false;
+    }
+    return true;
+  }
+  /** For testing: number of active (non-expired) sessions. */
+  get size() {
+    this.evictExpired();
+    return this.store.size;
+  }
+  evictExpired() {
+    const now = Date.now();
+    for (const [id, entry] of this.store) {
+      if (now > entry.expiresAt) this.store.delete(id);
+    }
+  }
+};
+
+// src/context.ts
+var CHARS_PER_TOKEN = 4;
+function estimateTokens(messages) {
+  let chars = 0;
+  for (const msg of messages) {
+    for (const block of msg.content) {
+      chars += blockCharCount(block);
+    }
+  }
+  return Math.ceil(chars / CHARS_PER_TOKEN);
+}
+function blockCharCount(block) {
+  switch (block.type) {
+    case "text":
+      return block.text.length;
+    case "tool_use":
+      return block.name.length + JSON.stringify(block.input).length;
+    case "tool_result":
+      return block.content.length;
+  }
+}
+function compactMessages(messages, opts = {}) {
+  const maxTokens = opts.maxTokens ?? 1e5;
+  const keepRecent = opts.keepRecentCount ?? 6;
+  const systemTokens = opts.systemPromptTokens ?? 500;
+  const budget = maxTokens - systemTokens;
+  if (messages.length === 0) return [];
+  const mutable = messages.map((m) => ({
+    role: m.role,
+    content: m.content.map((b) => ({ ...b }))
+  }));
+  if (estimateTokens(mutable) <= budget) return mutable;
+  const splitIdx = Math.max(0, mutable.length - keepRecent);
+  for (let i = 0; i < splitIdx; i++) {
+    mutable[i].content = mutable[i].content.map((block) => {
+      if (block.type === "tool_result" && block.content.length > 200) {
+        return {
+          ...block,
+          content: truncateToolResult(block.content)
+        };
+      }
+      return block;
+    });
+  }
+  if (estimateTokens(mutable) <= budget) return mutable;
+  const first = mutable[0];
+  const recent = mutable.slice(splitIdx);
+  const oldSection = mutable.slice(1, splitIdx);
+  while (oldSection.length > 0 && estimateTokens([first, ...oldSection, ...recent]) > budget) {
+    oldSection.shift();
+  }
+  const compacted = [first, ...oldSection, ...recent];
+  if (estimateTokens(compacted) > budget) {
+    for (const msg of compacted) {
+      msg.content = msg.content.map((block) => {
+        if (block.type === "tool_result" && block.content.length > 100) {
+          return { ...block, content: truncateToolResult(block.content) };
+        }
+        return block;
+      });
+    }
+  }
+  return sanitizeMessages(compacted);
+}
+function sanitizeMessages(messages) {
+  const toolUseIds = /* @__PURE__ */ new Set();
+  const toolResultIds = /* @__PURE__ */ new Set();
+  for (const msg of messages) {
+    for (const block of msg.content) {
+      if (block.type === "tool_use") toolUseIds.add(block.id);
+      if (block.type === "tool_result") toolResultIds.add(block.toolUseId);
+    }
+  }
+  return messages.map((msg) => {
+    const filtered = msg.content.filter((block) => {
+      if (block.type === "tool_result") return toolUseIds.has(block.toolUseId);
+      if (block.type === "tool_use") return toolResultIds.has(block.id);
+      return true;
+    });
+    if (filtered.length === 0) return null;
+    return { ...msg, content: filtered };
+  }).filter((m) => m !== null);
+}
+function truncateToolResult(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed.error) {
+      return JSON.stringify({ error: parsed.error });
+    }
+    if (typeof parsed === "object" && parsed !== null) {
+      const summary = {};
+      for (const [key, value] of Object.entries(parsed)) {
+        if (typeof value === "number" || typeof value === "boolean") {
+          summary[key] = value;
+        } else if (typeof value === "string") {
+          summary[key] = value.length > 50 ? value.slice(0, 50) + "\u2026" : value;
+        } else if (Array.isArray(value)) {
+          summary[key] = `[${value.length} items]`;
+        } else {
+          summary[key] = "{\u2026}";
+        }
+      }
+      return JSON.stringify(summary);
+    }
+    return content.slice(0, 100);
+  } catch {
+    return content.slice(0, 100);
+  }
+}
+
+// src/mcp.ts
+function buildMcpTools(context, tools) {
+  const engineTools = tools ?? getDefaultTools();
+  return engineTools.map((tool) => ({
+    name: `audric_${tool.name}`,
+    description: tool.description,
+    inputSchema: tool.jsonSchema,
+    async handler(args) {
+      try {
+        const parsed = tool.inputSchema.safeParse(args);
+        if (!parsed.success) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                error: `Invalid input: ${parsed.error.issues.map((i) => i.message).join(", ")}`
+              })
+            }],
+            isError: true
+          };
+        }
+        const result = await tool.call(parsed.data, context);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(result.data)
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              error: err instanceof Error ? err.message : "Tool execution failed"
+            })
+          }],
+          isError: true
+        };
+      }
+    }
+  }));
+}
+function registerEngineTools(server, context, tools) {
+  const descriptors = buildMcpTools(context, tools);
+  for (const desc of descriptors) {
+    server.tool(desc.name, desc.description, desc.inputSchema, desc.handler);
+  }
+}
+var McpResponseCache = class {
+  cache = /* @__PURE__ */ new Map();
+  defaultTtlMs;
+  constructor(defaultTtlMs = 3e4) {
+    this.defaultTtlMs = defaultTtlMs;
+  }
+  key(serverName, toolName, args) {
+    return `${serverName}::${toolName}::${JSON.stringify(args)}`;
+  }
+  get(serverName, toolName, args) {
+    const k = this.key(serverName, toolName, args);
+    const entry = this.cache.get(k);
+    if (!entry) return null;
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(k);
+      return null;
+    }
+    return entry.result;
+  }
+  set(serverName, toolName, args, result, ttlMs) {
+    const k = this.key(serverName, toolName, args);
+    this.cache.set(k, {
+      result,
+      expiresAt: Date.now() + (ttlMs ?? this.defaultTtlMs)
+    });
+  }
+  invalidate(serverName) {
+    if (!serverName) {
+      this.cache.clear();
+      return;
+    }
+    for (const key of this.cache.keys()) {
+      if (key.startsWith(`${serverName}::`)) {
+        this.cache.delete(key);
+      }
+    }
+  }
+  get size() {
+    return this.cache.size;
+  }
+};
+var McpClientManager = class {
+  connections = /* @__PURE__ */ new Map();
+  responseCache;
+  constructor(opts) {
+    this.responseCache = new McpResponseCache(opts?.cacheTtlMs ?? 3e4);
+  }
+  /**
+   * Connect to an MCP server and discover its tools.
+   * If already connected to a server with this name, disconnects first.
+   */
+  async connect(config) {
+    if (this.connections.has(config.name)) {
+      await this.disconnect(config.name);
+    }
+    const client = new Client(
+      { name: "audric-engine", version: "0.1.0" },
+      { capabilities: {} }
+    );
+    const transportType = config.transport ?? "streamable-http";
+    const url = new URL(config.url);
+    const transport = transportType === "sse" ? new SSEClientTransport(url) : new StreamableHTTPClientTransport(url, {
+      reconnectionOptions: {
+        maxReconnectionDelay: 3e4,
+        initialReconnectionDelay: 1e3,
+        reconnectionDelayGrowFactor: 1.5,
+        maxRetries: 3
+      }
+    });
+    const conn = {
+      config,
+      client,
+      transport,
+      tools: [],
+      status: "disconnected"
+    };
+    try {
+      await client.connect(transport);
+      conn.status = "connected";
+      const { tools } = await client.listTools();
+      conn.tools = tools;
+    } catch (err) {
+      try {
+        await client.close();
+      } catch {
+      }
+      throw err;
+    }
+    this.connections.set(config.name, conn);
+    return conn;
+  }
+  /** Disconnect from a server by name. */
+  async disconnect(name) {
+    const conn = this.connections.get(name);
+    if (!conn) return;
+    try {
+      await conn.client.close();
+    } catch {
+    }
+    conn.status = "disconnected";
+    conn.tools = [];
+    this.connections.delete(name);
+    this.responseCache.invalidate(name);
+  }
+  /** Disconnect from all servers. */
+  async disconnectAll() {
+    const names = [...this.connections.keys()];
+    await Promise.allSettled(names.map((n) => this.disconnect(n)));
+  }
+  /** Get a connection by server name. */
+  getConnection(name) {
+    return this.connections.get(name);
+  }
+  /** Check if a server is connected. */
+  isConnected(name) {
+    return this.connections.get(name)?.status === "connected";
+  }
+  /** List all tool definitions across all connected servers. */
+  listAllTools() {
+    const result = [];
+    for (const [name, conn] of this.connections) {
+      if (conn.status !== "connected") continue;
+      for (const tool of conn.tools) {
+        result.push({ serverName: name, tool });
+      }
+    }
+    return result;
+  }
+  /**
+   * Call a tool on a specific server.
+   * Uses response cache for read-only servers.
+   */
+  async callTool(serverName, toolName, args = {}) {
+    const conn = this.connections.get(serverName);
+    if (!conn) throw new Error(`MCP server "${serverName}" not connected`);
+    if (conn.status !== "connected") throw new Error(`MCP server "${serverName}" is ${conn.status}`);
+    const cacheTtl = conn.config.cacheTtlMs ?? 3e4;
+    if (conn.config.readOnly !== false && cacheTtl > 0) {
+      const cached = this.responseCache.get(serverName, toolName, args);
+      if (cached) return cached;
+    }
+    const result = await conn.client.callTool({ name: toolName, arguments: args });
+    const callResult = {
+      content: result.content ?? [],
+      isError: result.isError
+    };
+    if (conn.config.readOnly !== false && cacheTtl > 0) {
+      this.responseCache.set(serverName, toolName, args, callResult, cacheTtl);
+    }
+    return callResult;
+  }
+  /** Get the response cache (for testing / manual invalidation). */
+  get cache() {
+    return this.responseCache;
+  }
+  /** Number of connected servers. */
+  get serverCount() {
+    let count = 0;
+    for (const conn of this.connections.values()) {
+      if (conn.status === "connected") count++;
+    }
+    return count;
+  }
+  /** All server names. */
+  get serverNames() {
+    return [...this.connections.keys()];
+  }
+};
+function adaptMcpTool(mcpTool, config) {
+  const overrides = config.toolOverrides?.[mcpTool.name];
+  const isReadOnly = overrides?.isReadOnly ?? config.isReadOnly ?? true;
+  const permissionLevel = overrides?.permissionLevel ?? config.permissionLevel ?? "auto";
+  const namespacedName = `${config.serverName}_${mcpTool.name}`;
+  const jsonSchema = mcpTool.inputSchema ?? {
+    type: "object",
+    properties: {}
+  };
+  return {
+    name: namespacedName,
+    description: overrides?.description ?? mcpTool.description ?? `MCP tool: ${mcpTool.name}`,
+    inputSchema: z.record(z.unknown()),
+    jsonSchema,
+    isReadOnly,
+    isConcurrencySafe: isReadOnly,
+    permissionLevel,
+    async call(input, _context) {
+      const result = await config.manager.callTool(
+        config.serverName,
+        mcpTool.name,
+        input
+      );
+      const textContent = result.content.filter((c) => c.type === "text" && c.text).map((c) => c.text).join("\n");
+      let data;
+      try {
+        data = JSON.parse(textContent);
+      } catch {
+        data = textContent || result.content;
+      }
+      if (result.isError) {
+        return { data: { error: data } };
+      }
+      return { data };
+    }
+  };
+}
+function adaptAllMcpTools(config) {
+  const conn = config.manager.getConnection(config.serverName);
+  if (!conn || conn.status !== "connected") {
+    return [];
+  }
+  return conn.tools.map((t) => adaptMcpTool(t, config));
+}
+function adaptAllServerTools(manager, serverConfigs) {
+  const allTools = [];
+  for (const { serverName, tool } of manager.listAllTools()) {
+    const serverOpts = serverConfigs?.[serverName] ?? {};
+    allTools.push(adaptMcpTool(tool, {
+      manager,
+      serverName,
+      ...serverOpts
+    }));
+  }
+  return allTools;
+}
+var DEFAULT_MODEL = "claude-sonnet-4-20250514";
+var DEFAULT_MAX_TOKENS2 = 4096;
+var AnthropicProvider = class {
+  client;
+  defaultModel;
+  defaultMaxTokens;
+  constructor(config) {
+    this.client = new Anthropic({ apiKey: config.apiKey });
+    this.defaultModel = config.defaultModel ?? DEFAULT_MODEL;
+    this.defaultMaxTokens = config.defaultMaxTokens ?? DEFAULT_MAX_TOKENS2;
+  }
+  async *chat(params) {
+    const messages = params.messages.map(toAnthropicMessage);
+    const tools = params.tools.map(toAnthropicTool);
+    const streamParams = {
+      model: params.model ?? this.defaultModel,
+      max_tokens: params.maxTokens ?? this.defaultMaxTokens,
+      system: params.systemPrompt,
+      messages,
+      tools: tools.length > 0 ? tools : void 0
+    };
+    const stream = params.signal ? this.client.messages.stream(streamParams, { signal: params.signal }) : this.client.messages.stream(streamParams);
+    const toolInputBuffers = /* @__PURE__ */ new Map();
+    let outputTokensFromStart = 0;
+    try {
+      for await (const event of stream) {
+        switch (event.type) {
+          case "message_start": {
+            const msg = event.message;
+            yield {
+              type: "message_start",
+              messageId: msg.id,
+              model: msg.model
+            };
+            if (msg.usage) {
+              const u = msg.usage;
+              outputTokensFromStart = msg.usage.output_tokens;
+              yield {
+                type: "usage",
+                inputTokens: msg.usage.input_tokens,
+                outputTokens: msg.usage.output_tokens,
+                cacheReadTokens: u.cache_read_input_tokens,
+                cacheWriteTokens: u.cache_creation_input_tokens
+              };
+            }
+            break;
+          }
+          case "content_block_start": {
+            const block = event.content_block;
+            if (block.type === "tool_use") {
+              toolInputBuffers.set(event.index, {
+                id: block.id,
+                name: block.name,
+                json: ""
+              });
+              yield {
+                type: "tool_use_start",
+                id: block.id,
+                name: block.name
+              };
+            }
+            break;
+          }
+          case "content_block_delta": {
+            const delta = event.delta;
+            if (delta.type === "text_delta") {
+              yield { type: "text_delta", text: delta.text };
+            } else if (delta.type === "input_json_delta") {
+              const buf = toolInputBuffers.get(event.index);
+              if (buf) {
+                buf.json += delta.partial_json;
+                yield {
+                  type: "tool_use_delta",
+                  id: buf.id,
+                  partialJson: delta.partial_json
+                };
+              }
+            }
+            break;
+          }
+          case "content_block_stop": {
+            const buf = toolInputBuffers.get(event.index);
+            if (buf) {
+              let input = {};
+              try {
+                input = JSON.parse(buf.json || "{}");
+              } catch {
+                input = {};
+              }
+              yield {
+                type: "tool_use_done",
+                id: buf.id,
+                name: buf.name,
+                input
+              };
+              toolInputBuffers.delete(event.index);
+            }
+            break;
+          }
+          case "message_delta": {
+            const delta = event.delta;
+            const usage = event.usage;
+            if (usage?.output_tokens && usage.output_tokens > outputTokensFromStart) {
+              const increment = usage.output_tokens - outputTokensFromStart;
+              outputTokensFromStart = usage.output_tokens;
+              yield {
+                type: "usage",
+                inputTokens: 0,
+                outputTokens: increment
+              };
+            }
+            if (delta.stop_reason) {
+              yield {
+                type: "stop",
+                reason: mapStopReason(delta.stop_reason)
+              };
+            }
+            break;
+          }
+        }
+      }
+    } finally {
+      stream.abort();
+    }
+  }
+};
+function toAnthropicMessage(msg) {
+  const content = msg.content.map((block) => {
+    switch (block.type) {
+      case "text":
+        return { type: "text", text: block.text };
+      case "tool_use":
+        return {
+          type: "tool_use",
+          id: block.id,
+          name: block.name,
+          input: block.input
+        };
+      case "tool_result":
+        return {
+          type: "tool_result",
+          tool_use_id: block.toolUseId,
+          content: block.content,
+          is_error: block.isError
+        };
+    }
+  });
+  return { role: msg.role, content };
+}
+function toAnthropicTool(def) {
+  return {
+    name: def.name,
+    description: def.description,
+    input_schema: def.input_schema
+  };
+}
+function mapStopReason(reason) {
+  switch (reason) {
+    case "end_turn":
+      return "end_turn";
+    case "tool_use":
+      return "tool_use";
+    case "max_tokens":
+      return "max_tokens";
+    default:
+      return "end_turn";
+  }
+}
+
+export { AnthropicProvider, CostTracker, DEFAULT_SYSTEM_PROMPT, McpClientManager, McpResponseCache, MemorySessionStore, NAVI_MCP_CONFIG, NAVI_MCP_URL, NAVI_SERVER_NAME, NaviTools, PermissionBridge, QueryEngine, READ_TOOLS, 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 };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map