@exagent/agent 0.1.46 → 0.1.48

package/dist/cli.js

@@ -332,7 +332,7 @@ function getTokenDecimals(address) {
 function getTokenSymbol(address) {
   return _globalResolver?.getSymbol(address.toLowerCase());
 }
-var import_viem2, import_chains, NATIVE_ETH, _globalResolver, TOKEN_DECIMALS, TOKEN_TO_COINGECKO, STABLECOIN_IDS, PRICE_STALENESS_MS, MarketDataService;
+var import_viem2, import_chains, NATIVE_ETH, _globalResolver, TOKEN_DECIMALS, TOKEN_TO_COINGECKO, STABLECOIN_IDS, PRICE_STALENESS_MS, HISTORY_STALENESS_MS, MarketDataService;
 var init_market = __esm({
   "src/trading/market.ts"() {
     "use strict";
@@ -498,6 +498,7 @@ var init_market = __esm({
     };
     STABLECOIN_IDS = /* @__PURE__ */ new Set(["usd-coin", "dai", "tether"]);
     PRICE_STALENESS_MS = 6e4;
+    HISTORY_STALENESS_MS = 60 * 6e4;
     MarketDataService = class {
       rpcUrl;
       client;
@@ -510,6 +511,10 @@ var init_market = __esm({
       cachedVolume24h = {};
       /** Cached price change data */
       cachedPriceChange24h = {};
+      /** Cached 24h hourly price history per token address */
+      cachedPriceHistory = {};
+      /** Timestamp of last successful price history fetch */
+      lastHistoryFetchAt = 0;
       constructor(rpcUrl, store) {
         this.rpcUrl = rpcUrl;
         this.client = (0, import_viem2.createPublicClient)({
@@ -530,11 +535,10 @@ var init_market = __esm({
         const prices = await this.fetchPrices(tokenAddresses);
         const balances = await this.fetchBalances(walletAddress, tokenAddresses);
         const portfolioValue = this.calculatePortfolioValue(balances, prices);
-        let gasPrice;
-        try {
-          gasPrice = await this.client.getGasPrice();
-        } catch {
-        }
+        const [priceHistory, gasPrice] = await Promise.all([
+          this.fetchPriceHistory(tokenAddresses).catch(() => void 0),
+          this.client.getGasPrice().catch(() => void 0)
+        ]);
         return {
           timestamp: Date.now(),
           prices,
@@ -545,7 +549,8 @@ var init_market = __esm({
           gasPrice,
           network: {
             chainId: this.client.chain?.id ?? 8453
-          }
+          },
+          priceHistory: priceHistory && Object.keys(priceHistory).length > 0 ? priceHistory : void 0
         };
       }
       /**
@@ -718,6 +723,58 @@ var init_market = __esm({
         }
         return prices;
       }
+      /**
+       * Fetch 24h hourly price history from CoinGecko.
+       * Returns cached data if still fresh (< 60 min old).
+       * Only fetches for tokens with known CoinGecko IDs.
+       */
+      async fetchPriceHistory(tokenAddresses) {
+        if (Date.now() - this.lastHistoryFetchAt < HISTORY_STALENESS_MS && Object.keys(this.cachedPriceHistory).length > 0) {
+          return { ...this.cachedPriceHistory };
+        }
+        const history = {};
+        const idToAddrs = {};
+        for (const addr of tokenAddresses) {
+          const cgId = TOKEN_TO_COINGECKO[addr.toLowerCase()];
+          if (cgId && !STABLECOIN_IDS.has(cgId)) {
+            if (!idToAddrs[cgId]) idToAddrs[cgId] = [];
+            idToAddrs[cgId].push(addr.toLowerCase());
+          }
+        }
+        const ids = Object.keys(idToAddrs);
+        for (let i = 0; i < ids.length; i++) {
+          const cgId = ids[i];
+          try {
+            const resp = await fetch(
+              `https://api.coingecko.com/api/v3/coins/${cgId}/market_chart?vs_currency=usd&days=1`,
+              { signal: AbortSignal.timeout(5e3) }
+            );
+            if (!resp.ok) {
+              if (resp.status === 429) {
+                console.warn("CoinGecko rate limit hit during price history fetch \u2014 using partial data");
+                break;
+              }
+              continue;
+            }
+            const data = await resp.json();
+            if (data.prices && Array.isArray(data.prices)) {
+              const candles = data.prices.map(([ts, price]) => ({ timestamp: ts, price }));
+              for (const addr of idToAddrs[cgId]) {
+                history[addr] = candles;
+              }
+            }
+          } catch {
+          }
+          if (i < ids.length - 1) {
+            await new Promise((r) => setTimeout(r, 2500));
+          }
+        }
+        if (Object.keys(history).length > 0) {
+          this.cachedPriceHistory = { ...this.cachedPriceHistory, ...history };
+          this.lastHistoryFetchAt = Date.now();
+        }
+        return { ...this.cachedPriceHistory };
+      }
       /**
        * Fetch real on-chain balances: native ETH + ERC-20 tokens.
        * Uses Multicall3 to batch all balanceOf calls into a single RPC request.
@@ -1552,16 +1609,25 @@ var init_executor = __esm({
       config;
       allowedTokens;
       configHashFn;
-      constructor(client, config, configHashFn) {
+      vaultManager;
+      constructor(client, config, configHashFn, vaultManager) {
         this.client = client;
         this.config = config;
         this.configHashFn = configHashFn;
+        this.vaultManager = vaultManager;
         this.allowedTokens = new Set(
           (config.allowedTokens || []).map((t) => t.toLowerCase())
         );
       }
       /**
-       * Execute a single trade signal
+       * Set the vault manager (allows wiring after construction)
+       */
+      setVaultManager(vm) {
+        this.vaultManager = vm;
+      }
+      /**
+       * Execute a single trade signal.
+       * Tries vault trading first if vault exists, falls back to wallet trading.
        */
       async execute(signal) {
         if (signal.action === "hold") {
@@ -1574,13 +1640,38 @@ var init_executor = __esm({
             return { success: false, error: "Signal exceeds position limits" };
           }
           const configHash = this.configHashFn?.();
-          const result = await this.client.trade({
+          const tradeIntent = {
             tokenIn: signal.tokenIn,
             tokenOut: signal.tokenOut,
             amountIn: signal.amountIn,
             maxSlippageBps: this.config.trading?.maxSlippageBps ?? 100,
             ...configHash && { configHash }
-          });
+          };
+          if (this.vaultManager) {
+            const vaultAddress = await this.vaultManager.getVaultAddress();
+            if (vaultAddress && this.vaultManager.preferVaultTrading) {
+              const routerTrade = await this.client.buildRouterTrade(tradeIntent);
+              if (routerTrade.vaultParams) {
+                console.log(`Attempting vault trade via ${vaultAddress}`);
+                const vaultResult = await this.vaultManager.executeVaultTrade({
+                  tokenIn: signal.tokenIn,
+                  tokenOut: signal.tokenOut,
+                  amountIn: BigInt(signal.amountIn),
+                  minAmountOut: BigInt(routerTrade.minAmountOut),
+                  vaultParams: routerTrade.vaultParams
+                });
+                if (vaultResult) {
+                  if (vaultResult.txHash) {
+                    console.log(`Vault trade executed: ${vaultResult.txHash}`);
+                    return { success: true, txHash: vaultResult.txHash };
+                  }
+                  console.error(`Vault trade failed: ${vaultResult.error}`);
+                  return { success: false, error: vaultResult.error };
+                }
+              }
+            }
+          }
+          const result = await this.client.trade(tradeIntent);
           console.log(`Trade executed: ${result.hash}`);
           return { success: true, txHash: result.hash };
         } catch (error) {
@@ -1609,6 +1700,10 @@ var init_executor = __esm({
        * Validate a signal against config limits and token restrictions
        */
       validateSignal(signal) {
+        if (signal.amountIn <= 0n) {
+          console.warn(`Signal amountIn is ${signal.amountIn} \u2014 skipping (must be positive)`);
+          return false;
+        }
         if (signal.confidence < 0.5) {
           console.warn(`Signal confidence ${signal.confidence} below threshold (0.5)`);
           return false;
@@ -2553,6 +2648,33 @@ function formatSessionReport(result) {
     }
     lines.push("");
   }
+  if (result.trades.length > 0) {
+    lines.push(`  ${thinDivider}`);
+    lines.push("  TRADE LOG");
+    lines.push(`  ${thinDivider}`);
+    lines.push("");
+    const recentTrades = result.trades.slice(-50);
+    for (const t of recentTrades) {
+      const time = new Date(t.timestamp).toLocaleString(void 0, {
+        month: "short",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit"
+      });
+      const tag = t.action === "buy" ? "BUY " : "SELL";
+      const tokenIn = t.tokenIn.slice(0, 6) + "\u2026";
+      const tokenOut = t.tokenOut.slice(0, 6) + "\u2026";
+      const value = `$${t.valueInUSD.toFixed(2)}`;
+      const pnl = t.valueOutUSD - t.valueInUSD - t.feeUSD - t.gasUSD;
+      const pnlStr = pnl >= 0 ? `+$${pnl.toFixed(2)}` : `-$${Math.abs(pnl).toFixed(2)}`;
+      const reason = t.reasoning ? `  "${t.reasoning.slice(0, 60)}"` : "";
+      lines.push(`  ${time}  ${tag}  ${tokenIn}\u2192${tokenOut}  ${value}  ${pnlStr}${reason}`);
+    }
+    if (result.trades.length > 50) {
+      lines.push(`  ... and ${result.trades.length - 50} earlier trades`);
+    }
+    lines.push("");
+  }
   if (result.equityCurve.length >= 3) {
     lines.push(`  ${thinDivider}`);
     lines.push("  EQUITY CURVE");
@@ -3886,7 +4008,7 @@ var STRATEGY_TEMPLATES = [
   {
     id: "momentum",
     name: "Momentum Trader",
-    description: "Follows price trends and momentum indicators. Buys assets with strong upward momentum.",
+    description: "Follows price trends and momentum indicators. Buys assets with strong upward momentum, sells when momentum fades.",
     riskLevel: "medium",
     riskWarnings: [
       "Momentum strategies can suffer significant losses during trend reversals",
@@ -3894,60 +4016,248 @@ var STRATEGY_TEMPLATES = [
       "Past performance does not guarantee future results",
       "This strategy may underperform in sideways markets"
     ],
-    systemPrompt: `You are an AI trading analyst specializing in momentum trading strategies.
+    systemPrompt: `You are an AI trading analyst specializing in momentum trading on Base network.
 
-Your role is to analyze market data and identify momentum-based trading opportunities.
+Analyze the provided market data and identify momentum-based trading opportunities.
 
-IMPORTANT CONSTRAINTS:
+RULES:
 - Only recommend trades when there is clear momentum evidence
-- Always consider risk/reward ratios
-- Never recommend more than the configured position size limits
-- Be conservative with confidence scores
+- Use priceTrends (1h, 4h, 12h, 24h changes) as your primary momentum signal
+- Fall back to priceChange24h if priceTrends is not available
+- Be conservative with confidence \u2014 only use > 0.6 for strong signals
+- Never recommend buying a token you already hold significant amounts of
+- Always consider selling positions that have lost momentum
+- Return "hold" signals when uncertain \u2014 doing nothing is often the best trade
 
-When analyzing data, look for:
-1. Price trends (higher highs, higher lows for uptrends)
-2. Volume confirmation (increasing volume on moves)
-3. Relative strength vs market benchmarks
+ANALYZE:
+1. Multi-timeframe momentum: use priceTrends (1h, 4h, 12h, 24h) to confirm trend direction
+2. Strong momentum = positive across all timeframes. Divergence (e.g., 1h negative, 12h positive) = weakening
+3. Volume confirmation: prefer tokens with > $10K daily volume
+4. Portfolio concentration: avoid putting > 20% in any single token
+5. Exit signals: sell when short-term trend (1h, 4h) turns negative on a held position
 
-Respond with JSON in this format:
+Respond with ONLY valid JSON (no markdown, no code fences):
 {
-  "analysis": "Brief market analysis",
+  "analysis": "Brief market analysis (1-2 sentences)",
   "signals": [
     {
       "action": "buy" | "sell" | "hold",
-      "tokenIn": "0x...",
-      "tokenOut": "0x...",
-      "percentage": 0-100,
-      "confidence": 0-1,
-      "reasoning": "Why this trade"
+      "token": "0x... (token address to buy/sell)",
+      "percentage": 5-25,
+      "confidence": 0.0-1.0,
+      "reasoning": "Why this trade (1 sentence)"
     }
   ]
-}`,
-    exampleCode: `import { StrategyFunction, MarketData, TradeSignal, LLMAdapter, AgentConfig } from '@exagent/agent';
+}
+
+If no good opportunities exist, return: { "analysis": "No clear momentum signals", "signals": [] }`,
+    exampleCode: `import type { StrategyFunction, MarketData, TradeSignal, LLMAdapter, AgentConfig, StrategyContext } from '@exagent/agent';
+
+// Well-known token addresses on Base
+const WETH = '0x4200000000000000000000000000000000000006';
+const USDC = '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913';
 
+// Token decimals lookup (extend as needed)
+const DECIMALS: Record<string, number> = {
+  [WETH]: 18,
+  [USDC]: 6,
+};
+
+/**
+ * Format balances for LLM consumption (human-readable amounts)
+ */
+function formatBalances(balances: Record<string, bigint>, prices: Record<string, number>): Record<string, { amount: string; usdValue: string }> {
+  const result: Record<string, { amount: string; usdValue: string }> = {};
+  for (const [token, balance] of Object.entries(balances)) {
+    if (balance === 0n) continue;
+    const decimals = DECIMALS[token.toLowerCase()] ?? 18;
+    const amount = Number(balance) / (10 ** decimals);
+    const price = prices[token.toLowerCase()] ?? 0;
+    result[token] = {
+      amount: amount.toFixed(decimals <= 8 ? decimals : 6),
+      usdValue: (amount * price).toFixed(2),
+    };
+  }
+  return result;
+}
+
+/**
+ * Convert LLM percentage signal to a TradeSignal with bigint amountIn
+ *
+ * The LLM says "buy token X with 10% of my ETH" \u2014 this function converts
+ * that percentage into the actual wei amount to trade.
+ */
+function toTradeSignal(
+  signal: { action: string; token: string; percentage: number; confidence: number; reasoning?: string },
+  balances: Record<string, bigint>,
+): TradeSignal | null {
+  const { action, token, percentage, confidence, reasoning } = signal;
+
+  // Skip hold signals and low confidence
+  if (action === 'hold' || confidence < 0.5) return null;
+
+  // Clamp percentage to 1-50 range for safety
+  const pct = Math.max(1, Math.min(50, percentage));
+
+  if (action === 'buy') {
+    // Buying: spend ETH (or USDC) to acquire the target token
+    // Use ETH balance as the source
+    const ethBalance = balances[WETH] ?? 0n;
+    if (ethBalance === 0n) return null;
+    const amountIn = (ethBalance * BigInt(Math.round(pct * 100))) / 10000n;
+    if (amountIn === 0n) return null;
+    return { action: 'buy', tokenIn: WETH, tokenOut: token, amountIn, confidence, reasoning };
+  }
+
+  if (action === 'sell') {
+    // Selling: sell the target token for ETH
+    const tokenBalance = balances[token.toLowerCase()] ?? balances[token] ?? 0n;
+    if (tokenBalance === 0n) return null;
+    const amountIn = (tokenBalance * BigInt(Math.round(pct * 100))) / 10000n;
+    if (amountIn === 0n) return null;
+    return { action: 'sell', tokenIn: token, tokenOut: WETH, amountIn, confidence, reasoning };
+  }
+
+  return null;
+}
+
+/**
+ * Momentum Trading Strategy
+ *
+ * Sends market data to the LLM, parses the response, and converts
+ * percentage-based signals into executable TradeSignal objects.
+ */
 export const generateSignals: StrategyFunction = async (
   marketData: MarketData,
   llm: LLMAdapter,
-  config: AgentConfig
+  config: AgentConfig,
+  context?: StrategyContext,
 ): Promise<TradeSignal[]> => {
+  // Summarize price history into compact trend data for the LLM
+  // Instead of sending 24 raw candles per token, compute useful signals:
+  // - 1h, 4h, 12h, 24h price changes (momentum at different timeframes)
+  const priceTrends: Record<string, { '1h': string; '4h': string; '12h': string; '24h': string }> = {};
+  if (marketData.priceHistory) {
+    for (const [addr, candles] of Object.entries(marketData.priceHistory)) {
+      if (candles.length < 2) continue;
+      const latest = candles[candles.length - 1].price;
+      const getChangeAt = (hoursAgo: number): string => {
+        const target = Date.now() - hoursAgo * 3600_000;
+        // Find the candle closest to the target time
+        let closest = candles[0];
+        for (const c of candles) {
+          if (Math.abs(c.timestamp - target) < Math.abs(closest.timestamp - target)) closest = c;
+        }
+        if (closest.price === 0) return '0.0%';
+        const pct = ((latest - closest.price) / closest.price) * 100;
+        return (pct >= 0 ? '+' : '') + pct.toFixed(1) + '%';
+      };
+      priceTrends[addr] = {
+        '1h': getChangeAt(1),
+        '4h': getChangeAt(4),
+        '12h': getChangeAt(12),
+        '24h': getChangeAt(24),
+      };
+    }
+  }
+
+  // Build the data payload for the LLM
+  const payload: Record<string, unknown> = {
+    prices: marketData.prices,
+    balances: formatBalances(marketData.balances, marketData.prices),
+    portfolioValueUSD: marketData.portfolioValue.toFixed(2),
+    priceChange24h: marketData.priceChange24h ?? {},
+    volume24h: marketData.volume24h ?? {},
+    recentTrades: (context?.tradeHistory ?? []).slice(0, 5).map(t => ({
+      action: t.action,
+      token: t.action === 'buy' ? t.tokenOut : t.tokenIn,
+      reasoning: t.reasoning,
+      timestamp: new Date(t.timestamp).toISOString(),
+    })),
+  };
+
+  // Include price trends if available (more useful than raw candles for LLM)
+  if (Object.keys(priceTrends).length > 0) {
+    payload.priceTrends = priceTrends;
+  }
+
+  // Call the LLM
   const response = await llm.chat([
-    { role: 'system', content: MOMENTUM_SYSTEM_PROMPT },
-    { role: 'user', content: JSON.stringify({
-      prices: marketData.prices,
-      balances: formatBalances(marketData.balances),
-      portfolioValue: marketData.portfolioValue,
-    })}
+    { role: 'system', content: config.strategyPrompt ?? MOMENTUM_SYSTEM_PROMPT },
+    { role: 'user', content: JSON.stringify(payload) },
   ]);
 
-  // Parse LLM response and convert to TradeSignals
-  const parsed = JSON.parse(response.content);
-  return parsed.signals.map(convertToTradeSignal);
-};`
+  // Parse the response \u2014 handle markdown code fences if the LLM wraps its output
+  let content = response.content.trim();
+  if (content.startsWith('\`\`\`')) {
+    content = content.replace(/^\`\`\`(?:json)?\\n?/, '').replace(/\\n?\`\`\`$/, '').trim();
+  }
+
+  let parsed: { signals?: Array<{ action: string; token: string; percentage: number; confidence: number; reasoning?: string }> };
+  try {
+    parsed = JSON.parse(content);
+  } catch (e) {
+    console.error('[strategy] Failed to parse LLM response:', (e as Error).message);
+    console.error('[strategy] Raw response:', content.slice(0, 200));
+    return []; // Safe fallback: no trades
+  }
+
+  if (!parsed.signals || !Array.isArray(parsed.signals)) {
+    return [];
+  }
+
+  // Convert each signal to a TradeSignal with proper bigint amountIn
+  const signals: TradeSignal[] = [];
+  for (const raw of parsed.signals) {
+    const signal = toTradeSignal(raw, marketData.balances);
+    if (signal) signals.push(signal);
+  }
+
+  return signals;
+};
+
+// Default system prompt \u2014 used when config.strategyPrompt is not set
+const MOMENTUM_SYSTEM_PROMPT = \`You are an AI trading analyst specializing in momentum trading on Base network.
+
+Analyze the provided market data and identify momentum-based trading opportunities.
+
+RULES:
+- Only recommend trades when there is clear momentum evidence
+- Use priceTrends (1h, 4h, 12h, 24h changes) as your primary momentum signal
+- Fall back to priceChange24h if priceTrends is not available
+- Be conservative with confidence \u2014 only use > 0.6 for strong signals
+- Never recommend buying a token you already hold significant amounts of
+- Always consider selling positions that have lost momentum
+- Return "hold" signals when uncertain \u2014 doing nothing is often the best trade
+
+ANALYZE:
+1. Multi-timeframe momentum: use priceTrends (1h, 4h, 12h, 24h) to confirm trend direction
+2. Strong momentum = positive across all timeframes. Divergence (e.g., 1h negative, 12h positive) = weakening
+3. Volume confirmation: prefer tokens with > $10K daily volume
+4. Portfolio concentration: avoid putting > 20% in any single token
+5. Exit signals: sell when short-term trend (1h, 4h) turns negative on a held position
+
+Respond with ONLY valid JSON (no markdown, no code fences):
+{
+  "analysis": "Brief market analysis (1-2 sentences)",
+  "signals": [
+    {
+      "action": "buy" | "sell" | "hold",
+      "token": "0x... (token address to buy/sell)",
+      "percentage": 5-25,
+      "confidence": 0.0-1.0,
+      "reasoning": "Why this trade (1 sentence)"
+    }
+  ]
+}
+
+If no good opportunities exist, return: { "analysis": "No clear momentum signals", "signals": [] }\`;
+`
   },
   {
     id: "value",
     name: "Value Investor",
-    description: "Looks for undervalued assets based on fundamentals. Takes long-term positions.",
+    description: "Looks for undervalued assets based on fundamentals. Takes long-term positions with lower turnover.",
     riskLevel: "low",
     riskWarnings: [
       "Value traps can result in prolonged losses",
@@ -3955,47 +4265,135 @@ export const generateSignals: StrategyFunction = async (
       "Fundamental analysis may not apply well to all crypto assets",
       "Market sentiment can override fundamentals for long periods"
     ],
-    systemPrompt: `You are an AI trading analyst specializing in value investing.
+    systemPrompt: `You are an AI trading analyst specializing in value investing on Base network.
 
 Your role is to identify undervalued assets with strong fundamentals.
 
-IMPORTANT CONSTRAINTS:
+RULES:
 - Focus on long-term value, not short-term price movements
 - Only recommend assets with clear value propositions
 - Consider protocol revenue, TVL, active users, developer activity
-- Be very selective - quality over quantity
-
-When analyzing, consider:
-1. Protocol fundamentals (revenue, TVL, user growth)
-2. Token economics (supply schedule, utility)
-3. Competitive positioning
-4. Valuation relative to peers
+- Be very selective \u2014 quality over quantity
+- Prefer established tokens (AERO, WELL, MORPHO, COMP, CRV) over memecoins
+- Hold positions for days/weeks, not hours
 
-Respond with JSON in this format:
+Respond with ONLY valid JSON:
 {
   "analysis": "Brief fundamental analysis",
   "signals": [
     {
       "action": "buy" | "sell" | "hold",
-      "tokenIn": "0x...",
-      "tokenOut": "0x...",
-      "percentage": 0-100,
-      "confidence": 0-1,
+      "token": "0x... (token address)",
+      "percentage": 5-20,
+      "confidence": 0.0-1.0,
       "reasoning": "Fundamental thesis"
     }
   ]
 }`,
-    exampleCode: `import { StrategyFunction } from '@exagent/agent';
+    exampleCode: `import type { StrategyFunction, MarketData, TradeSignal, LLMAdapter, AgentConfig, StrategyContext } from '@exagent/agent';
+
+const WETH = '0x4200000000000000000000000000000000000006';
+const USDC = '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913';
+const DECIMALS: Record<string, number> = { [WETH]: 18, [USDC]: 6 };
+
+function formatBalances(balances: Record<string, bigint>, prices: Record<string, number>): Record<string, { amount: string; usdValue: string }> {
+  const result: Record<string, { amount: string; usdValue: string }> = {};
+  for (const [token, balance] of Object.entries(balances)) {
+    if (balance === 0n) continue;
+    const decimals = DECIMALS[token.toLowerCase()] ?? 18;
+    const amount = Number(balance) / (10 ** decimals);
+    const price = prices[token.toLowerCase()] ?? 0;
+    result[token] = { amount: amount.toFixed(6), usdValue: (amount * price).toFixed(2) };
+  }
+  return result;
+}
+
+function toTradeSignal(
+  signal: { action: string; token: string; percentage: number; confidence: number; reasoning?: string },
+  balances: Record<string, bigint>,
+): TradeSignal | null {
+  if (signal.action === 'hold' || signal.confidence < 0.5) return null;
+  const pct = Math.max(1, Math.min(50, signal.percentage));
+  if (signal.action === 'buy') {
+    const ethBalance = balances[WETH] ?? 0n;
+    if (ethBalance === 0n) return null;
+    const amountIn = (ethBalance * BigInt(Math.round(pct * 100))) / 10000n;
+    if (amountIn === 0n) return null;
+    return { action: 'buy', tokenIn: WETH, tokenOut: signal.token, amountIn, confidence: signal.confidence, reasoning: signal.reasoning };
+  }
+  if (signal.action === 'sell') {
+    const tokenBalance = balances[signal.token.toLowerCase()] ?? balances[signal.token] ?? 0n;
+    if (tokenBalance === 0n) return null;
+    const amountIn = (tokenBalance * BigInt(Math.round(pct * 100))) / 10000n;
+    if (amountIn === 0n) return null;
+    return { action: 'sell', tokenIn: signal.token, tokenOut: WETH, amountIn, confidence: signal.confidence, reasoning: signal.reasoning };
+  }
+  return null;
+}
+
+export const generateSignals: StrategyFunction = async (
+  marketData: MarketData,
+  llm: LLMAdapter,
+  config: AgentConfig,
+  context?: StrategyContext,
+): Promise<TradeSignal[]> => {
+  const payload = {
+    prices: marketData.prices,
+    balances: formatBalances(marketData.balances, marketData.prices),
+    portfolioValueUSD: marketData.portfolioValue.toFixed(2),
+    priceChange24h: marketData.priceChange24h ?? {},
+    positions: (context?.positions ?? []).map(p => ({
+      token: p.tokenAddress,
+      entryPrice: p.averageEntryPrice,
+      currentAmount: p.currentAmount.toString(),
+    })),
+  };
 
-export const generateSignals: StrategyFunction = async (marketData, llm, config) => {
-  // Value strategy runs less frequently
   const response = await llm.chat([
-    { role: 'system', content: VALUE_SYSTEM_PROMPT },
-    { role: 'user', content: JSON.stringify(marketData) }
+    { role: 'system', content: config.strategyPrompt ?? VALUE_SYSTEM_PROMPT },
+    { role: 'user', content: JSON.stringify(payload) },
   ]);
 
-  return parseSignals(response.content);
-};`
+  let content = response.content.trim();
+  if (content.startsWith('\\\`\\\`\\\`')) {
+    content = content.replace(/^\\\`\\\`\\\`(?:json)?\\n?/, '').replace(/\\n?\\\`\\\`\\\`$/, '').trim();
+  }
+
+  try {
+    const parsed = JSON.parse(content);
+    if (!parsed.signals || !Array.isArray(parsed.signals)) return [];
+    return parsed.signals.map((s: any) => toTradeSignal(s, marketData.balances)).filter(Boolean) as TradeSignal[];
+  } catch (e) {
+    console.error('[strategy] Failed to parse LLM response:', (e as Error).message);
+    return [];
+  }
+};
+
+const VALUE_SYSTEM_PROMPT = \`You are an AI trading analyst specializing in value investing on Base network.
+
+Your role is to identify undervalued assets with strong fundamentals.
+
+RULES:
+- Focus on long-term value, not short-term price movements
+- Only recommend assets with clear value propositions
+- Be very selective \u2014 quality over quantity
+- Prefer established tokens over memecoins
+- Hold positions for days/weeks, not hours
+
+Respond with ONLY valid JSON:
+{
+  "analysis": "Brief fundamental analysis",
+  "signals": [
+    {
+      "action": "buy" | "sell" | "hold",
+      "token": "0x... (token address)",
+      "percentage": 5-20,
+      "confidence": 0.0-1.0,
+      "reasoning": "Fundamental thesis"
+    }
+  ]
+}\`;
+`
   },
   {
     id: "arbitrage",
@@ -4035,7 +4433,7 @@ Respond with JSON in this format:
     exampleCode: `// Note: Pure arbitrage requires specialized infrastructure
 // This template is for educational purposes
 
-import { StrategyFunction } from '@exagent/agent';
+import type { StrategyFunction } from '@exagent/agent';
 
 export const generateSignals: StrategyFunction = async (marketData, llm, config) => {
   // Arbitrage requires real-time price feeds from multiple sources
@@ -4067,18 +4465,21 @@ Respond with JSON:
 {
   "signals": []
 }`,
-    exampleCode: `import { StrategyFunction, MarketData, TradeSignal, LLMAdapter, AgentConfig } from '@exagent/agent';
+    exampleCode: `import type { StrategyFunction, MarketData, TradeSignal, LLMAdapter, AgentConfig, StrategyContext } from '@exagent/agent';
+
+const WETH = '0x4200000000000000000000000000000000000006';
 
 /**
  * Custom Strategy Template
  *
  * Customize this file with your own trading logic and prompts.
- * Your prompts are YOUR intellectual property - we don't store them.
+ * Your prompts are YOUR intellectual property \u2014 we don't store them.
  */
 export const generateSignals: StrategyFunction = async (
   marketData: MarketData,
   llm: LLMAdapter,
-  config: AgentConfig
+  config: AgentConfig,
+  context?: StrategyContext,
 ): Promise<TradeSignal[]> => {
   // Your custom system prompt (this is your secret sauce)
   const systemPrompt = \`
@@ -4088,13 +4489,26 @@ export const generateSignals: StrategyFunction = async (
   // Call the LLM with your prompt
   const response = await llm.chat([
     { role: 'system', content: systemPrompt },
-    { role: 'user', content: JSON.stringify(marketData) }
+    { role: 'user', content: JSON.stringify({
+      prices: marketData.prices,
+      balances: Object.fromEntries(
+        Object.entries(marketData.balances)
+          .filter(([, v]) => v > 0n)
+          .map(([k, v]) => [k, v.toString()])
+      ),
+      portfolioValue: marketData.portfolioValue,
+    })},
   ]);
 
   // Parse and return signals
   // IMPORTANT: Validate LLM output before using
+  let content = response.content.trim();
+  if (content.startsWith('\\\`\\\`\\\`')) {
+    content = content.replace(/^\\\`\\\`\\\`(?:json)?\\n?/, '').replace(/\\n?\\\`\\\`\\\`$/, '').trim();
+  }
+
   try {
-    const parsed = JSON.parse(response.content);
+    const parsed = JSON.parse(content);
     return parsed.signals || [];
   } catch (e) {
     console.error('Failed to parse LLM response:', e);
@@ -4103,6 +4517,9 @@ export const generateSignals: StrategyFunction = async (
 };`
   }
 ];
+function getStrategyTemplate(id) {
+  return STRATEGY_TEMPLATES.find((t) => t.id === id);
+}
 function getAllStrategyTemplates() {
   return STRATEGY_TEMPLATES;
 }
@@ -4250,6 +4667,8 @@ var AgentConfigSchema = import_zod.z.object({
   perp: PerpConfigSchema,
   // Prediction market configuration (Polymarket)
   prediction: PredictionConfigSchema,
+  // Custom strategy system prompt (overrides built-in template prompt)
+  strategyPrompt: import_zod.z.string().optional(),
   // Allowed tokens (addresses)
   allowedTokens: import_zod.z.array(import_zod.z.string()).optional()
 });
@@ -4388,9 +4807,10 @@ var VAULT_ABI = [
     outputs: [{ type: "uint256" }],
     stateMutability: "view"
   },
+  // TOKEN → base asset (fee from output)
   {
     type: "function",
-    name: "executeTrade",
+    name: "executeSwap",
     inputs: [
       { name: "tokenIn", type: "address" },
       { name: "tokenOut", type: "address" },
@@ -4398,6 +4818,44 @@ var VAULT_ABI = [
       { name: "minAmountOut", type: "uint256" },
       { name: "aggregator", type: "address" },
       { name: "swapData", type: "bytes" },
+      { name: "feeConvertAggregator", type: "address" },
+      { name: "feeSwapData", type: "bytes" },
+      { name: "deadline", type: "uint256" }
+    ],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  // Base asset → TOKEN (fee from input)
+  {
+    type: "function",
+    name: "executeSwapSimple",
+    inputs: [
+      { name: "tokenIn", type: "address" },
+      { name: "tokenOut", type: "address" },
+      { name: "amountIn", type: "uint256" },
+      { name: "minAmountOut", type: "uint256" },
+      { name: "target", type: "address" },
+      { name: "data", type: "bytes" },
+      { name: "feeConvertAggregator", type: "address" },
+      { name: "feeSwapData", type: "bytes" },
+      { name: "deadline", type: "uint256" }
+    ],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  // TOKEN → TOKEN (multi-hop via USDC, fee at midpoint)
+  {
+    type: "function",
+    name: "executeSwapMultiHop",
+    inputs: [
+      { name: "tokenIn", type: "address" },
+      { name: "tokenOut", type: "address" },
+      { name: "amountIn", type: "uint256" },
+      { name: "minAmountOut", type: "uint256" },
+      { name: "aggregator1", type: "address" },
+      { name: "swapData1", type: "bytes" },
+      { name: "aggregator2", type: "address" },
+      { name: "swapData2", type: "bytes" },
       { name: "deadline", type: "uint256" }
     ],
     outputs: [{ type: "uint256" }],
@@ -4663,8 +5121,9 @@ var VaultManager = class {
     }
   }
   /**
-   * Execute a trade through the vault (if it exists and policy allows)
-   * Returns null if should use direct trading instead
+   * Execute a trade through the vault using API-provided vaultParams.
+   * Dispatches to the correct vault function based on swapType.
+   * Returns null if vault trading shouldn't be used (no vault, policy disabled).
    */
   async executeVaultTrade(params) {
     if (!this.preferVaultTrading) {
@@ -4675,23 +5134,71 @@ var VaultManager = class {
       return null;
     }
     const deadline = params.deadline || BigInt(Math.floor(Date.now() / 1e3) + 3600);
+    const { vaultParams } = params;
     try {
-      const hash = await this.walletClient.writeContract({
-        address: vaultAddress,
-        abi: VAULT_ABI,
-        functionName: "executeTrade",
-        args: [
-          params.tokenIn,
-          params.tokenOut,
-          params.amountIn,
-          params.minAmountOut,
-          params.aggregator,
-          params.swapData,
-          deadline
-        ],
-        chain: import_chains2.base,
-        account: this.account
-      });
+      let hash;
+      switch (vaultParams.swapType) {
+        case "swap":
+          hash = await this.walletClient.writeContract({
+            address: vaultAddress,
+            abi: VAULT_ABI,
+            functionName: "executeSwap",
+            args: [
+              params.tokenIn,
+              params.tokenOut,
+              params.amountIn,
+              params.minAmountOut,
+              vaultParams.aggregator,
+              vaultParams.swapData,
+              vaultParams.feeConvertAggregator,
+              vaultParams.feeSwapData,
+              deadline
+            ],
+            chain: import_chains2.base,
+            account: this.account
+          });
+          break;
+        case "simple":
+          hash = await this.walletClient.writeContract({
+            address: vaultAddress,
+            abi: VAULT_ABI,
+            functionName: "executeSwapSimple",
+            args: [
+              params.tokenIn,
+              params.tokenOut,
+              params.amountIn,
+              params.minAmountOut,
+              vaultParams.target,
+              vaultParams.data,
+              vaultParams.feeConvertAggregator,
+              vaultParams.feeSwapData,
+              deadline
+            ],
+            chain: import_chains2.base,
+            account: this.account
+          });
+          break;
+        case "multihop":
+          hash = await this.walletClient.writeContract({
+            address: vaultAddress,
+            abi: VAULT_ABI,
+            functionName: "executeSwapMultiHop",
+            args: [
+              params.tokenIn,
+              params.tokenOut,
+              params.amountIn,
+              params.minAmountOut,
+              vaultParams.aggregator1,
+              vaultParams.swapData1,
+              vaultParams.aggregator2,
+              vaultParams.swapData2,
+              deadline
+            ],
+            chain: import_chains2.base,
+            account: this.account
+          });
+          break;
+      }
       return { usedVault: true, txHash: hash };
     } catch (error) {
       return {
@@ -7949,7 +8456,7 @@ function loadSecureEnv(basePath, passphrase) {
 }
 
 // src/index.ts
-var AGENT_VERSION = "0.1.46";
+var AGENT_VERSION = "0.1.48";
 
 // src/relay.ts
 var RelayClient = class {
@@ -8410,10 +8917,16 @@ var AgentRuntime = class {
       vaultConfig
     });
     console.log(`Vault policy: ${vaultConfig.policy}`);
+    if (this.executor) {
+      this.executor.setVaultManager(this.vaultManager);
+    }
     const status = await this.vaultManager.getVaultStatus();
     if (status.hasVault) {
       console.log(`Vault exists: ${status.vaultAddress}`);
       console.log(`Vault TVL: ${Number(status.totalAssets) / 1e6} USDC`);
+      if (vaultConfig.preferVaultTrading) {
+        console.log("Vault trading enabled \u2014 trades will execute from vault");
+      }
     } else {
       console.log("No vault exists for this agent");
       if (vaultConfig.policy === "manual") {
@@ -9834,8 +10347,9 @@ This exit has been recorded in your trade history and counts toward your total P
         this.paperPortfolio.save();
       } else {
         const vaultStatus = await this.vaultManager?.getVaultStatus();
-        if (vaultStatus?.hasVault && this.vaultManager?.preferVaultTrading) {
-          console.log(`Trading through vault: ${vaultStatus.vaultAddress}`);
+        if (vaultStatus?.hasVault) {
+          const via = this.vaultManager?.preferVaultTrading ? "vault" : "wallet";
+          console.log(`Vault active: ${vaultStatus.vaultAddress} (trades execute from ${via})`);
         }
         const results = await this.executor.executeAll(filteredSignals);
         let totalFeesUSD = 0;
@@ -10659,6 +11173,95 @@ ${llmEnvVar}EXAGENT_LLM_MODEL=${config.llm?.model || ""}
     (0, import_dotenv2.config)({ path: envPath, override: true });
   }
 }
+program.command("init").description("Scaffold a new agent project with strategy template and config").option("-t, --template <template>", "Strategy template (momentum, value, arbitrage, custom)", "momentum").option("--force", "Overwrite existing files without prompting").action(async (options) => {
+  try {
+    const templateId = options.template;
+    const template = getStrategyTemplate(templateId);
+    if (!template) {
+      const templates = getAllStrategyTemplates();
+      console.error(`Unknown template: ${templateId}`);
+      console.error(`Available templates: ${templates.map((t) => t.id).join(", ")}`);
+      process.exit(1);
+    }
+    console.log("");
+    console.log("=".repeat(50));
+    console.log("  EXAGENT INIT");
+    console.log("=".repeat(50));
+    console.log("");
+    console.log(`  Template: ${template.name}`);
+    console.log(`  Risk:     ${template.riskLevel}`);
+    console.log("");
+    const cwd = process.cwd();
+    const strategyPath = path7.join(cwd, "strategy.ts");
+    const configPath = path7.join(cwd, "agent-config.json");
+    const existingFiles = [];
+    if (fs6.existsSync(strategyPath)) existingFiles.push("strategy.ts");
+    if (fs6.existsSync(configPath)) existingFiles.push("agent-config.json");
+    if (existingFiles.length > 0 && !options.force) {
+      console.log(`  Files already exist: ${existingFiles.join(", ")}`);
+      const answer = await prompt("  Overwrite? (y/n): ");
+      if (answer.toLowerCase() !== "y") {
+        console.log("  Aborted.");
+        process.exit(0);
+      }
+      console.log("");
+    }
+    fs6.writeFileSync(strategyPath, template.exampleCode.trim() + "\n");
+    console.log("  Created: strategy.ts");
+    const defaultConfig = {
+      agentId: 0,
+      name: "my-agent",
+      network: "mainnet",
+      llm: {
+        provider: "openai",
+        model: "gpt-4o",
+        temperature: 0.7,
+        maxTokens: 4096
+      },
+      riskUniverse: "established",
+      trading: {
+        timeHorizon: "swing",
+        maxPositionSizeBps: 1e3,
+        maxDailyLossBps: 500,
+        maxConcurrentPositions: 5,
+        tradingIntervalMs: 6e4,
+        maxSlippageBps: 100,
+        minTradeValueUSD: 1
+      },
+      wallet: {
+        setup: "generate"
+      },
+      relay: {
+        enabled: true,
+        apiUrl: "https://exagent-api.onrender.com"
+      }
+    };
+    if (!fs6.existsSync(configPath) || options.force || existingFiles.includes("agent-config.json")) {
+      fs6.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2) + "\n");
+      console.log("  Created: agent-config.json");
+    }
+    console.log("");
+    console.log("=".repeat(50));
+    console.log("  NEXT STEPS");
+    console.log("=".repeat(50));
+    console.log("");
+    console.log("  1. Register your agent at https://exagent.io/deploy");
+    console.log("  2. Copy your agent ID into agent-config.json");
+    console.log("  3. Update agent-config.json with your name and LLM provider");
+    console.log("  4. Run: npx @exagent/agent paper");
+    console.log("     (paper trade first to validate your strategy)");
+    console.log("");
+    console.log("  5. When ready for real trading:");
+    console.log("     npx @exagent/agent run");
+    console.log("");
+    console.log("=".repeat(50));
+    console.log("");
+    process.exit(0);
+  } catch (error) {
+    console.error("Error:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+});
 program.command("run").description("Start the trading agent").option("-c, --config <path>", "Path to agent-config.json", "agent-config.json").option("-p, --passphrase <passphrase>", "Passphrase to decrypt .env.enc").action(async (options) => {
   try {
     await checkFirstRunSetup(options.config);