@exagent/agent 0.1.40 → 0.1.42

package/dist/index.js

@@ -884,16 +884,20 @@ var TOKEN_SYMBOLS = {
 var KEY_POSITIONS = "__positions";
 var KEY_TRADE_HISTORY = "__trade_history";
 var KEY_RISK_STATE = "__risk_state";
+var KEY_SELL_FAILURES = "__sell_failures";
+var STUCK_FAILURE_THRESHOLD = 3;
 var PositionTracker = class {
   store;
   positions;
   tradeHistory;
+  sellFailures;
   maxTradeHistory;
   constructor(store, options) {
     this.store = store;
     this.maxTradeHistory = options?.maxTradeHistory ?? 50;
     this.positions = store.get(KEY_POSITIONS) || {};
     this.tradeHistory = store.get(KEY_TRADE_HISTORY) || [];
+    this.sellFailures = store.get(KEY_SELL_FAILURES) || {};
     const posCount = Object.keys(this.positions).length;
     if (posCount > 0 || this.tradeHistory.length > 0) {
       console.log(`Position tracker loaded: ${posCount} positions, ${this.tradeHistory.length} trade records`);
@@ -929,10 +933,10 @@ var PositionTracker = class {
         const realizedPnL = this.handleSell(tokenIn.toLowerCase(), tradeValueUSD);
         record.realizedPnL = realizedPnL;
       }
-    }
-    this.tradeHistory.unshift(record);
-    if (this.tradeHistory.length > this.maxTradeHistory) {
-      this.tradeHistory = this.tradeHistory.slice(0, this.maxTradeHistory);
+      this.tradeHistory.unshift(record);
+      if (this.tradeHistory.length > this.maxTradeHistory) {
+        this.tradeHistory = this.tradeHistory.slice(0, this.maxTradeHistory);
+      }
     }
     this.persist();
   }
@@ -993,26 +997,58 @@ var PositionTracker = class {
   // ============================================================
   /**
    * Sync tracked positions with on-chain balances.
-   * Updates currentAmount, detects new tokens (airdrops), removes zeroed positions.
+   * Updates currentAmount, detects new tokens (airdrops), and handles position exits.
+   *
+   * CRITICAL: When a tracked position's balance decreases without a corresponding
+   * sell trade, we infer a manual exit and record it with realized PnL calculated
+   * at current market price. This prevents PnL manipulation via off-router sells.
+   *
+   * Returns array of inferred exits for the runtime to report to Command Center.
    */
   syncBalances(balances, prices) {
     let changed = false;
+    const inferredExits = [];
     for (const [address, balance] of Object.entries(balances)) {
       const token = address.toLowerCase();
       if (BASE_ASSETS.has(token)) continue;
       const decimals = getTokenDecimals(token);
       const amount = Number(balance) / Math.pow(10, decimals);
+      const position = this.positions[token];
       if (amount > 0) {
-        if (this.positions[token]) {
-          if (this.positions[token].currentAmount !== amount) {
-            this.positions[token].currentAmount = amount;
-            this.positions[token].lastUpdateTimestamp = Date.now();
+        if (position) {
+          const previousAmount = position.currentAmount;
+          if (amount < previousAmount && position.totalAmountAcquired > 0) {
+            const exitedAmount = previousAmount - amount;
+            const currentPrice = prices[token] || position.averageEntryPrice || 0;
+            const exitValueUSD = exitedAmount * currentPrice;
+            const costBasisOfExited = exitedAmount * position.averageEntryPrice;
+            const realizedPnL = exitValueUSD - costBasisOfExited;
+            const symbol = position.symbol || TOKEN_SYMBOLS[token] || getTokenSymbol(token) || token.slice(0, 10);
+            this.recordInferredExit(token, exitedAmount, exitValueUSD, realizedPnL, symbol);
+            inferredExits.push({
+              token,
+              symbol,
+              amountExited: exitedAmount,
+              exitValueUSD,
+              realizedPnL,
+              costBasis: costBasisOfExited
+            });
+            const exitRatio = exitedAmount / position.totalAmountAcquired;
+            position.totalCostBasis = Math.max(0, position.totalCostBasis * (1 - exitRatio));
+            position.totalAmountAcquired = Math.max(0, position.totalAmountAcquired - exitedAmount);
+            console.log(
+              `Position tracker: inferred exit of ${exitedAmount.toFixed(4)} ${symbol} ($${exitValueUSD.toFixed(2)} value, PnL: $${realizedPnL >= 0 ? "+" : ""}${realizedPnL.toFixed(2)})`
+            );
+          }
+          if (position.currentAmount !== amount) {
+            position.currentAmount = amount;
+            position.lastUpdateTimestamp = Date.now();
             changed = true;
           }
-          if (!this.positions[token].symbol) {
+          if (!position.symbol) {
             const resolved = TOKEN_SYMBOLS[token] || getTokenSymbol(token);
             if (resolved) {
-              this.positions[token].symbol = resolved;
+              position.symbol = resolved;
               changed = true;
             }
           }
@@ -1035,14 +1071,60 @@ var PositionTracker = class {
           }
           changed = true;
         }
-      } else if (this.positions[token]) {
+      } else if (position) {
+        if (position.totalAmountAcquired > 0 && position.currentAmount > 0) {
+          const currentPrice = prices[token] || position.averageEntryPrice || 0;
+          const exitValueUSD = position.currentAmount * currentPrice;
+          const costBasisOfExited = position.currentAmount * position.averageEntryPrice;
+          const realizedPnL = exitValueUSD - costBasisOfExited;
+          const symbol = position.symbol || TOKEN_SYMBOLS[token] || getTokenSymbol(token) || token.slice(0, 10);
+          this.recordInferredExit(token, position.currentAmount, exitValueUSD, realizedPnL, symbol);
+          inferredExits.push({
+            token,
+            symbol,
+            amountExited: position.currentAmount,
+            exitValueUSD,
+            realizedPnL,
+            costBasis: costBasisOfExited
+          });
+          console.log(
+            `Position tracker: inferred FULL exit of ${position.currentAmount.toFixed(4)} ${symbol} ($${exitValueUSD.toFixed(2)} value, PnL: $${realizedPnL >= 0 ? "+" : ""}${realizedPnL.toFixed(2)})`
+          );
+        }
         delete this.positions[token];
+        if (this.sellFailures[token]) {
+          delete this.sellFailures[token];
+        }
         changed = true;
       }
     }
-    if (changed) {
+    if (changed || inferredExits.length > 0) {
       this.persist();
     }
+    return inferredExits;
+  }
+  /**
+   * Record an inferred exit in trade history.
+   * These are exits detected from balance changes, not from tracked sell executions.
+   */
+  recordInferredExit(token, amount, valueUSD, realizedPnL, symbol) {
+    const record = {
+      timestamp: Date.now(),
+      action: "sell",
+      tokenIn: token,
+      tokenOut: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+      // USDC (assumed exit to stablecoin)
+      amountIn: amount.toString(),
+      priceUSD: valueUSD,
+      reasoning: `Inferred exit: balance decreased without tracked sell. Exited ${amount.toFixed(4)} ${symbol} at ~$${(valueUSD / amount).toFixed(4)}/token.`,
+      realizedPnL,
+      success: true,
+      inferred: true
+    };
+    this.tradeHistory.unshift(record);
+    if (this.tradeHistory.length > this.maxTradeHistory) {
+      this.tradeHistory = this.tradeHistory.slice(0, this.maxTradeHistory);
+    }
   }
   // ============================================================
   // QUERY METHODS (for strategies)
@@ -1083,6 +1165,86 @@ var PositionTracker = class {
     return Object.values(pnl).reduce((sum, v) => sum + v, 0);
   }
   // ============================================================
+  // STUCK POSITION DETECTION
+  // ============================================================
+  /**
+   * Record a sell failure for a token. Called when a sell attempt fails
+   * due to liquidity issues, route simulation failure, or excessive price impact.
+   */
+  recordSellFailure(token, reason) {
+    const key = token.toLowerCase();
+    const existing = this.sellFailures[key];
+    if (existing) {
+      existing.consecutiveFailures += 1;
+      existing.lastFailureReason = reason;
+      existing.lastFailureTimestamp = Date.now();
+    } else {
+      this.sellFailures[key] = {
+        consecutiveFailures: 1,
+        lastFailureReason: reason,
+        lastFailureTimestamp: Date.now()
+      };
+    }
+    this.store.set(KEY_SELL_FAILURES, this.sellFailures);
+  }
+  /**
+   * Clear sell failure tracking for a token (called after successful sell).
+   */
+  clearSellFailure(token) {
+    const key = token.toLowerCase();
+    if (this.sellFailures[key]) {
+      delete this.sellFailures[key];
+      this.store.set(KEY_SELL_FAILURES, this.sellFailures);
+    }
+  }
+  /**
+   * Detect positions that are "stuck" — we've tried and failed to sell them
+   * multiple times, likely due to insufficient liquidity.
+   *
+   * Returns positions that have failed to sell >= STUCK_FAILURE_THRESHOLD times.
+   */
+  getStuckPositions(prices) {
+    const stuck = [];
+    const now = Date.now();
+    for (const [token, failure] of Object.entries(this.sellFailures)) {
+      if (failure.consecutiveFailures < STUCK_FAILURE_THRESHOLD) continue;
+      const position = this.positions[token];
+      if (!position || position.currentAmount <= 0) continue;
+      const price = prices[token] || position.averageEntryPrice || 0;
+      const estimatedValueUSD = position.currentAmount * price;
+      stuck.push({
+        token,
+        symbol: position.symbol || TOKEN_SYMBOLS[token] || token.slice(0, 10),
+        consecutiveFailures: failure.consecutiveFailures,
+        lastFailureReason: failure.lastFailureReason,
+        holdingDurationMs: now - position.entryTimestamp,
+        estimatedValueUSD
+      });
+    }
+    return stuck;
+  }
+  /**
+   * Check if a specific position is stuck.
+   */
+  isPositionStuck(token) {
+    const failure = this.sellFailures[token.toLowerCase()];
+    return !!failure && failure.consecutiveFailures >= STUCK_FAILURE_THRESHOLD;
+  }
+  /**
+   * Check if we should alert about a stuck position (rate-limited to once per 24h).
+   * Returns true if we should alert, and marks the alert as sent.
+   */
+  shouldAlertStuckPosition(token) {
+    const alertKey = `__stuck_alert_${token.toLowerCase()}`;
+    const lastAlert = this.store.get(alertKey) || 0;
+    const hoursSinceAlert = (Date.now() - lastAlert) / (1e3 * 60 * 60);
+    if (hoursSinceAlert >= 24) {
+      this.store.set(alertKey, Date.now());
+      return true;
+    }
+    return false;
+  }
+  // ============================================================
   // RISK STATE PERSISTENCE
   // ============================================================
   /** Load persisted risk state */
@@ -2146,7 +2308,9 @@ function validateConfig(config) {
     throw new Error("Endpoint required for custom LLM provider");
   }
   if (!config.agentId || Number(config.agentId) <= 0) {
-    throw new Error("Valid agent ID required");
+    throw new Error(
+      'Valid agent ID required in agent-config.json.\n\n  Register your agent at https://exagent.io first:\n    1. Connect your wallet\n    2. Click "Launch Agent" to register\n    3. Copy your agent ID into agent-config.json as "agentId"\n'
+    );
   }
 }
 var DEFAULT_RPC_URL = "https://mainnet.base.org";
@@ -2666,13 +2830,6 @@ var VAULT_FACTORY_ABI = [
     outputs: [{ type: "address" }],
     stateMutability: "view"
   },
-  {
-    type: "function",
-    name: "canCreateVault",
-    inputs: [{ name: "creator", type: "address" }],
-    outputs: [{ name: "canCreate", type: "bool" }, { name: "reason", type: "string" }],
-    stateMutability: "view"
-  },
   {
     type: "function",
     name: "createVault",
@@ -2689,10 +2846,17 @@ var VAULT_FACTORY_ABI = [
   },
   {
     type: "function",
-    name: "minimumVeEXARequired",
+    name: "MIN_SEED_AMOUNT",
     inputs: [],
     outputs: [{ type: "uint256" }],
     stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "allowedAssets",
+    inputs: [{ name: "asset", type: "address" }],
+    outputs: [{ type: "bool" }],
+    stateMutability: "view"
   }
 ];
 var VAULT_ABI = [
@@ -2790,23 +2954,34 @@ var VaultManager = class {
       } catch {
       }
     }
-    const [canCreateResult, requirements] = await Promise.all([
-      this.publicClient.readContract({
-        address: this.addresses.vaultFactory,
-        abi: VAULT_FACTORY_ABI,
-        functionName: "canCreateVault",
-        args: [this.account.address]
-      }),
-      this.getRequirements()
-    ]);
+    let canCreate = true;
+    let cannotCreateReason = null;
+    if (hasVault) {
+      canCreate = false;
+      cannotCreateReason = "Vault already exists for this agent";
+    } else {
+      try {
+        const isAssetAllowed = await this.publicClient.readContract({
+          address: this.addresses.vaultFactory,
+          abi: VAULT_FACTORY_ABI,
+          functionName: "allowedAssets",
+          args: [this.addresses.usdc]
+        });
+        if (!isAssetAllowed) {
+          canCreate = false;
+          cannotCreateReason = "USDC is not an allowed asset on the vault factory";
+        }
+      } catch {
+      }
+    }
     return {
       hasVault,
       vaultAddress,
       totalAssets,
-      canCreateVault: canCreateResult[0],
-      cannotCreateReason: canCreateResult[0] ? null : canCreateResult[1],
-      requirementsMet: canCreateResult[0] || requirements.isBypassed,
-      requirements
+      canCreateVault: canCreate,
+      cannotCreateReason,
+      requirementsMet: canCreate,
+      requirements: { isBypassed: true }
     };
   }
   /**
@@ -2854,11 +3029,67 @@ var VaultManager = class {
     if (existingVault) {
       return { success: false, error: "Vault already exists", vaultAddress: existingVault };
     }
-    const status = await this.getVaultStatus();
-    if (!status.canCreateVault) {
-      return { success: false, error: status.cannotCreateReason || "Requirements not met" };
-    }
     const seed = seedAmount || BigInt(1e8);
+    let usdcBalance;
+    try {
+      usdcBalance = await this.publicClient.readContract({
+        address: this.addresses.usdc,
+        abi: import_viem3.erc20Abi,
+        functionName: "balanceOf",
+        args: [this.account.address]
+      });
+    } catch {
+      return { success: false, error: "Failed to read USDC balance" };
+    }
+    if (usdcBalance < seed) {
+      const needed = Number(seed) / 1e6;
+      const have = Number(usdcBalance) / 1e6;
+      return {
+        success: false,
+        error: `Insufficient USDC: need ${needed} USDC seed but wallet has ${have} USDC. Fund ${this.account.address} with at least ${needed} USDC and retry.`
+      };
+    }
+    try {
+      const isAllowed = await this.publicClient.readContract({
+        address: this.addresses.vaultFactory,
+        abi: VAULT_FACTORY_ABI,
+        functionName: "allowedAssets",
+        args: [this.addresses.usdc]
+      });
+      if (!isAllowed) {
+        return { success: false, error: "USDC is not whitelisted on the vault factory. Contact protocol admin." };
+      }
+    } catch {
+    }
+    try {
+      const currentAllowance = await this.publicClient.readContract({
+        address: this.addresses.usdc,
+        abi: import_viem3.erc20Abi,
+        functionName: "allowance",
+        args: [this.account.address, this.addresses.vaultFactory]
+      });
+      if (currentAllowance < seed) {
+        console.log(`Approving ${Number(seed) / 1e6} USDC to VaultFactory...`);
+        const approveHash = await this.walletClient.writeContract({
+          address: this.addresses.usdc,
+          abi: import_viem3.erc20Abi,
+          functionName: "approve",
+          args: [this.addresses.vaultFactory, seed],
+          chain: import_chains2.base,
+          account: this.account
+        });
+        const approveReceipt = await this.publicClient.waitForTransactionReceipt({ hash: approveHash });
+        if (approveReceipt.status !== "success") {
+          return { success: false, error: "USDC approval transaction failed" };
+        }
+        console.log("USDC approved successfully");
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: `USDC approval failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      };
+    }
     const vaultName = this.config.vaultConfig.defaultName || `${this.config.agentName} Trading Vault`;
     const vaultSymbol = this.config.vaultConfig.defaultSymbol || `ex${this.config.agentName.replace(/[^a-zA-Z]/g, "").slice(0, 4).toUpperCase()}`;
     const feeRecipient = this.config.vaultConfig.feeRecipient || this.account.address;
@@ -2880,8 +3111,9 @@ var VaultManager = class {
       });
       const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
       if (receipt.status !== "success") {
-        return { success: false, error: "Transaction failed", txHash: hash };
+        return { success: false, error: "createVault transaction reverted on-chain", txHash: hash };
       }
+      this.lastVaultCheck = 0;
       const vaultAddress = await this.getVaultAddress();
       this.cachedVaultAddress = vaultAddress;
       return {
@@ -2890,10 +3122,23 @@ var VaultManager = class {
         txHash: hash
       };
     } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Unknown error"
-      };
+      const msg = error instanceof Error ? error.message : "Unknown error";
+      if (msg.includes("NotAgentOwner")) {
+        return { success: false, error: "This wallet is not the owner of the agent. Only the agent owner can create a fund." };
+      }
+      if (msg.includes("InsufficientStake")) {
+        return { success: false, error: "Staking requirement not met. This should not happen with StakingStub \u2014 contact protocol admin." };
+      }
+      if (msg.includes("FrontierCannotCreateVault")) {
+        return { success: false, error: "Frontier-risk agents cannot create funds. Change the agent risk universe first." };
+      }
+      if (msg.includes("VaultAlreadyExists")) {
+        return { success: false, error: "A fund already exists for this agent and asset." };
+      }
+      if (msg.includes("InsufficientSeed")) {
+        return { success: false, error: `Seed amount too low. Minimum is 100 USDC.` };
+      }
+      return { success: false, error: msg };
     }
   }
   /**
@@ -4667,7 +4912,7 @@ var HyperliquidWebSocket = class {
 var import_viem5 = require("viem");
 var import_chains3 = require("viem/chains");
 var import_accounts3 = require("viem/accounts");
-var ROUTER_ADDRESS = "0x1BCFa13f677fDCf697D8b7d5120f544817F1de1A";
+var ROUTER_ADDRESS = "0x20feB3054750970773Fe7370c391732EE0559743";
 var ROUTER_ABI = [
   {
     type: "function",
@@ -5740,7 +5985,7 @@ var PredictionPositionManager = class {
 var import_viem8 = require("viem");
 var import_chains5 = require("viem/chains");
 var import_accounts5 = require("viem/accounts");
-var ROUTER_ADDRESS2 = "0x1BCFa13f677fDCf697D8b7d5120f544817F1de1A";
+var ROUTER_ADDRESS2 = "0x20feB3054750970773Fe7370c391732EE0559743";
 var ROUTER_ABI2 = [
   {
     type: "function",
@@ -6975,7 +7220,18 @@ var AgentRuntime = class {
     console.log(`Wallet: ${this.client.address}`);
     const agent = await this.client.registry.getAgent(BigInt(this.config.agentId));
     if (!agent) {
-      throw new Error(`Agent ID ${this.config.agentId} not found on-chain. Please register first.`);
+      throw new Error(
+        `Agent ID ${this.config.agentId} not found on-chain.
+
+  Register your agent at https://exagent.io first:
+    1. Connect your wallet at https://exagent.io
+    2. Click "Launch Agent" to register (sets name, risk universe, limits)
+    3. Copy your agent ID into agent-config.json
+    4. Run your agent again
+
+  The website handles the full registration flow including risk parameters.
+  Your agent ID will appear on your agent's profile page after registration.`
+      );
     }
     console.log(`Agent verified: ${agent.name}`);
     await this.ensureWalletLinked();
@@ -7499,7 +7755,7 @@ var AgentRuntime = class {
       try {
         const tokens = this.getTokensToTrack();
         const initData = await this.marketData.fetchMarketData(this.client.address, tokens);
-        this.positionTracker.syncBalances(initData.balances, initData.prices);
+        void this.positionTracker.syncBalances(initData.balances, initData.prices);
         this.lastPortfolioValue = initData.portfolioValue;
         this.lastPrices = initData.prices;
         const nativeEthBal = initData.balances[NATIVE_ETH.toLowerCase()] || BigInt(0);
@@ -8351,7 +8607,31 @@ var AgentRuntime = class {
     this.lastPrices = marketData.prices;
     const nativeEthBal = marketData.balances[NATIVE_ETH.toLowerCase()] || BigInt(0);
     this.lastEthBalance = (Number(nativeEthBal) / 1e18).toFixed(6);
-    this.positionTracker.syncBalances(marketData.balances, marketData.prices);
+    const inferredExits = this.positionTracker.syncBalances(marketData.balances, marketData.prices);
+    for (const exit of inferredExits) {
+      const pnlSign = exit.realizedPnL >= 0 ? "+" : "";
+      this.relay?.sendMessage(
+        "position_inferred_exit",
+        exit.realizedPnL >= 0 ? "info" : "warning",
+        `Inferred Exit: ${exit.symbol}`,
+        `Detected manual sell of ${exit.amountExited.toFixed(4)} ${exit.symbol} outside the ExagentRouter.
+
+Exit value: $${exit.exitValueUSD.toFixed(2)}
+Cost basis: $${exit.costBasis.toFixed(2)}
+Realized PnL: ${pnlSign}$${exit.realizedPnL.toFixed(2)}
+
+This exit has been recorded in your trade history and counts toward your total PnL.`,
+        {
+          token: exit.token,
+          symbol: exit.symbol,
+          amountExited: exit.amountExited,
+          exitValueUSD: exit.exitValueUSD,
+          realizedPnL: exit.realizedPnL,
+          costBasis: exit.costBasis,
+          inferred: true
+        }
+      );
+    }
     if (!isPaper) {
       const fundsOk = this.checkFundsLow(marketData);
       if (!fundsOk) {
@@ -8444,7 +8724,7 @@ var AgentRuntime = class {
           console.log(`  [PAPER] Cycle PnL: $${marketPnL.toFixed(2)} (market), -$${totalFeesUSD.toFixed(2)} (fees)`);
         }
         this.paperPortfolio.recordEquityPoint(marketData.prices);
-        this.positionTracker.syncBalances(this.paperPortfolio.getBalances(), marketData.prices);
+        void this.positionTracker.syncBalances(this.paperPortfolio.getBalances(), marketData.prices);
         this.lastPortfolioValue = postValue;
         this.paperPortfolio.save();
       } else {
@@ -8475,6 +8755,9 @@ var AgentRuntime = class {
                 tokenOut: result.signal.tokenOut
               }
             );
+            if (result.signal.action === "sell") {
+              this.positionTracker.clearSellFailure(result.signal.tokenIn);
+            }
           } else {
             console.warn(`Trade failed: ${result.error}`);
             this.relay?.sendMessage(
@@ -8484,6 +8767,41 @@ var AgentRuntime = class {
               result.error || "Unknown error",
               { action: result.signal.action }
             );
+            if (result.signal.action === "sell") {
+              const failedToken = result.signal.tokenIn.toLowerCase();
+              this.positionTracker.recordSellFailure(failedToken, result.error || "Unknown error");
+            }
+          }
+        }
+        const stuckPositions = this.positionTracker.getStuckPositions(marketData.prices);
+        for (const stuck of stuckPositions) {
+          if (this.positionTracker.shouldAlertStuckPosition(stuck.token)) {
+            const holdingDays = Math.floor(stuck.holdingDurationMs / (1e3 * 60 * 60 * 24));
+            this.relay?.sendMessage(
+              "position_stuck",
+              "warning",
+              `Position Stuck: ${stuck.symbol}`,
+              `Unable to sell ${stuck.symbol} after ${stuck.consecutiveFailures} attempts. This position has been held for ${holdingDays} days with ~$${stuck.estimatedValueUSD.toFixed(2)} value.
+
+Last error: ${stuck.lastFailureReason}
+
+MANUAL EXIT REQUIRED:
+1. Export your wallet key: npx @exagent/agent export-key
+2. Import into MetaMask or Rabby
+3. Go to Uniswap/Aerodrome and swap ${stuck.symbol} \u2192 ETH directly
+4. Use high slippage (10-20%) for illiquid tokens
+
+Note: Manual sells won't be tracked in your agent's PnL. The position will be removed from tracking once your balance is synced.
+
+See: https://exagent.io/docs/guides/manual-exit`,
+              {
+                token: stuck.token,
+                symbol: stuck.symbol,
+                consecutiveFailures: stuck.consecutiveFailures,
+                estimatedValueUSD: stuck.estimatedValueUSD,
+                holdingDurationMs: stuck.holdingDurationMs
+              }
+            );
           }
         }
         for (const result of results) {
@@ -8509,7 +8827,7 @@ var AgentRuntime = class {
         if (marketPnL !== 0) {
           console.log(`Cycle PnL: $${marketPnL.toFixed(2)} (market), -$${totalFeesUSD.toFixed(2)} (fees)`);
         }
-        this.positionTracker.syncBalances(postTradeData.balances, postTradeData.prices);
+        void this.positionTracker.syncBalances(postTradeData.balances, postTradeData.prices);
         this.lastPortfolioValue = postTradeData.portfolioValue;
         const postNativeEthBal = postTradeData.balances[NATIVE_ETH.toLowerCase()] || BigInt(0);
         this.lastEthBalance = (Number(postNativeEthBal) / 1e18).toFixed(6);
@@ -9125,7 +9443,7 @@ function loadSecureEnv(basePath, passphrase) {
 }
 
 // src/index.ts
-var AGENT_VERSION = "0.1.40";
+var AGENT_VERSION = "0.1.42";
 // 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-6VSAJQU7.mjs";
+} from "./chunk-R7LBXQH2.mjs";
 export {
   AGENT_VERSION,
   AgentConfigSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exagent/agent",
-  "version": "0.1.40",
+  "version": "0.1.42",
   "description": "Autonomous trading agent runtime for Exagent",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -29,7 +29,7 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@exagent/sdk": "^0.1.16",
+    "@exagent/sdk": "^0.1.19",
     "@nktkas/hyperliquid": "^0.31.0",
     "@polymarket/clob-client": "^4.0.0",
     "chalk": "^5.3.0",