@exagent/agent 0.1.47 → 0.1.48

package/dist/index.js

@@ -560,6 +560,7 @@ var TOKEN_TO_COINGECKO = {
 };
 var STABLECOIN_IDS = /* @__PURE__ */ new Set(["usd-coin", "dai", "tether"]);
 var PRICE_STALENESS_MS = 6e4;
+var HISTORY_STALENESS_MS = 60 * 6e4;
 var MarketDataService = class {
   rpcUrl;
   client;
@@ -572,6 +573,10 @@ var MarketDataService = class {
   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)({
@@ -592,11 +597,10 @@ var MarketDataService = class {
     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,
@@ -607,7 +611,8 @@ var MarketDataService = class {
       gasPrice,
       network: {
         chainId: this.client.chain?.id ?? 8453
-      }
+      },
+      priceHistory: priceHistory && Object.keys(priceHistory).length > 0 ? priceHistory : void 0
     };
   }
   /**
@@ -780,6 +785,58 @@ var MarketDataService = class {
     }
     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.
@@ -1897,7 +1954,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",
@@ -1905,60 +1962,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",
@@ -1966,47 +2211,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",
@@ -2046,7 +2379,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
@@ -2078,18 +2411,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 = \`
@@ -2099,13 +2435,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);
@@ -2264,6 +2613,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()
 });
@@ -2468,6 +2819,10 @@ var TradeExecutor = class {
    * 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;
@@ -4133,6 +4488,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");
@@ -9610,7 +9992,7 @@ function loadSecureEnv(basePath, passphrase) {
 }
 
 // src/index.ts
-var AGENT_VERSION = "0.1.47";
+var AGENT_VERSION = "0.1.48";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AGENT_VERSION,

package/dist/index.mjs

@@ -62,7 +62,7 @@ import {
   tradeIdToBytes32,
   validateConfig,
   validateStrategy
-} from "./chunk-ICTDJ7VX.mjs";
+} from "./chunk-V5XCNJWM.mjs";
 export {
   AGENT_VERSION,
   AgentConfigSchema,