@owney/sdk 0.2.5 → 0.2.7

package/dist/index.js

@@ -8,12 +8,76 @@ var P_SUPPORTED_CHAINS = {
 };
 var SUPPORTED_CHAIN_IDS = P_SUPPORTED_CHAINS.chainIds;
 var SUPPORTED_CHAINS = P_SUPPORTED_CHAINS.chains;
+var SupportedAssets = [
+  {
+    address: `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`,
+    symbol: "USDC",
+    chainId: 8453
+  },
+  {
+    address: `0xaf88d065e77c8cC2239327C5EDb3A432268e5831`,
+    symbol: "USDC",
+    chainId: 42161
+  },
+  {
+    address: `0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9`,
+    symbol: "USDT",
+    chainId: 42161
+  }
+];
+
+// src/errors.ts
+var OwneyError = class extends Error {
+  code;
+  details;
+  constructor(code, message, details) {
+    super(message);
+    this.name = "OwneyError";
+    this.code = code;
+    this.details = details;
+  }
+};
+var AgentNotFoundError = class extends OwneyError {
+  constructor(agentId, available) {
+    super(
+      "AGENT_NOT_FOUND",
+      `Unknown agent "${agentId}". Available agents: ${available.join(", ")}`,
+      { agentId, available }
+    );
+    this.name = "AgentNotFoundError";
+  }
+};
+var NotConnectedError = class extends OwneyError {
+  constructor() {
+    super("NOT_CONNECTED", "Not connected. Call sdk.connect(provider) first.");
+    this.name = "NotConnectedError";
+  }
+};
+var AgentChainIncompatibleError = class extends OwneyError {
+  incompatibleAgents;
+  connectedChainId;
+  constructor(incompatibleAgents, connectedChainId) {
+    const details = incompatibleAgents.map(
+      ({ agentId, supportedChainIds }) => `"${agentId}" supports chains [${supportedChainIds.join(", ")}]`
+    ).join("; ");
+    super(
+      "AGENT_CHAIN_INCOMPATIBLE",
+      `Chain ${connectedChainId} is not supported by the following agents: ${details}`,
+      { incompatibleAgents, connectedChainId }
+    );
+    this.name = "AgentChainIncompatibleError";
+    this.incompatibleAgents = incompatibleAgents;
+    this.connectedChainId = connectedChainId;
+  }
+};
 
 // src/lib/utils.ts
 var isValidChainId = (chainId) => {
   if (!SUPPORTED_CHAIN_IDS.includes(chainId)) {
-    throw new Error(
-      `Unsupported chain ID: ${chainId}. Supported chains: ${SUPPORTED_CHAIN_IDS.join(", ")}`
+    throw new OwneyError(
+      "CHAIN_UNSUPPORTED",
+      `Unsupported chain ID: ${chainId}. Supported chains: ${SUPPORTED_CHAIN_IDS.join(", ")}`,
+      { chainId, supportedChainIds: [...SUPPORTED_CHAIN_IDS] }
     );
   }
   return chainId;
@@ -28,6 +92,15 @@ function hexToDecimal(hex, decimals = 6) {
   const remainder = parsed % divisor;
   return Number(whole) + Number(remainder) / Number(divisor);
 }
+function normalizeDecimalPlace(value, decimals = 6) {
+  const parsed = BigInt(value);
+  if (decimals <= 0)
+    return Number(parsed);
+  const divisor = BigInt(10 ** decimals);
+  const whole = parsed / divisor;
+  const remainder = parsed % divisor;
+  return Number(whole) + Number(remainder) / Number(divisor);
+}
 var DayFilterMapping = {
   "30D": 30,
   "14D": 14,
@@ -57,7 +130,7 @@ var CHAIN_NAME_TO_ID = {
   BASE: 8453,
   ARBITRUM: 42161
 };
-function mapBalances(raw, chainId) {
+function mapBalances(raw, chainId, smartWallet) {
   const portfolio = raw.portfolio;
   const tokenMap = /* @__PURE__ */ new Map();
   for (const p of portfolio.positions || []) {
@@ -68,18 +141,7 @@ function mapBalances(raw, chainId) {
     tokenMap.set(key, {
       symbol,
       chainId: positionChainId,
-      amount: (current?.amount ?? 0) + hexToDecimal(p.amount || "0")
-    });
-  }
-  for (const s of portfolio.staleBalances || []) {
-    const symbol = s.tokenSymbol || "USDC";
-    const staleChainId = s.chainId ?? chainId;
-    const key = `${symbol}:${staleChainId}`;
-    const current = tokenMap.get(key);
-    tokenMap.set(key, {
-      symbol,
-      chainId: staleChainId,
-      amount: (current?.amount ?? 0) + hexToDecimal(s.balance || "0")
+      amount: (current?.amount ?? 0) + normalizeDecimalPlace(p.underlyingAmount || "0")
     });
   }
   let totalBalance = 0;
@@ -94,7 +156,7 @@ function mapBalances(raw, chainId) {
     });
   }
   return {
-    smartWallet: portfolio.smartWallet,
+    smartWallet,
     totalBalance: String(totalBalance),
     tokens
   };
@@ -185,13 +247,41 @@ function mapUserProfile(raw, userAddress) {
   };
 }
 function mapApyByStrategy(raw) {
-  const first = raw.data[0];
+  const apyPerAsset = {};
+  let apySum = 0;
+  let apyCount = 0;
+  for (const entry of raw.data) {
+    const supported = SupportedAssets.find(
+      (asset) => asset.chainId === entry.chain_id && asset.symbol === entry.token_symbol
+    );
+    if (!supported)
+      continue;
+    const chainKey = supported.chainId;
+    const symbolKey = supported.symbol;
+    const bucket = apyPerAsset[chainKey] ?? {};
+    bucket[symbolKey] = entry.average_apy;
+    apyPerAsset[chainKey] = bucket;
+    apySum += entry.average_apy;
+    apyCount += 1;
+  }
+  const averageApy = apyCount > 0 ? apySum / apyCount : 0;
+  const hasDetails = Object.keys(apyPerAsset).length > 0;
   return {
-    averageApy: first?.average_apy ?? 0
+    averageApy,
+    detailedApys: hasDetails ? { apyPerAsset } : void 0
   };
 }
 
 // src/agents/zyfai/zyfai.agent.ts
+var ZYFAI_TIMING_PREFIX = "[AgentTiming][zyfai]";
+function logTiming(label, startedAt, meta) {
+  const elapsedMs = Date.now() - startedAt;
+  if (meta) {
+    console.log(`${ZYFAI_TIMING_PREFIX} ${label} ${elapsedMs}ms`, meta);
+    return;
+  }
+  console.log(`${ZYFAI_TIMING_PREFIX} ${label} ${elapsedMs}ms`);
+}
 var ZyfaiAgent = class {
   id = "zyfai";
   supportedChainIds = [8453, 42161];
@@ -210,62 +300,122 @@ var ZyfaiAgent = class {
   sdk;
   connectedAddress = null;
   connectedChainId = null;
+  smartWalletCache = /* @__PURE__ */ new Map();
+  connectAuthPromise = null;
   constructor(apiKey) {
     this.sdk = new ZyfaiSDK({ apiKey });
   }
   // --- Private helpers ---
   getAddress() {
     if (!this.connectedAddress) {
-      throw new Error("Wallet not connected. Call sdk.connect() first.");
+      throw new OwneyError(
+        "NOT_CONNECTED",
+        "Wallet not connected. Call sdk.connect() first."
+      );
     }
     return this.connectedAddress;
   }
   /** Light connect: SIWE auth only. Re-auths if chain changed. */
   async connectAuth(state, chainId) {
+    const startedAt = Date.now();
     const validChainId = isValidChainId(chainId);
-    if (!this.connectedAddress || this.connectedChainId !== validChainId) {
+    if (this.connectedAddress && this.connectedChainId === validChainId) {
+      logTiming("connectAuth cache-hit", startedAt, { chainId: validChainId });
+      return;
+    }
+    if (this.connectAuthPromise) {
+      await this.connectAuthPromise;
+      logTiming("connectAuth awaited-inflight", startedAt, {
+        chainId: validChainId
+      });
+      return;
+    }
+    this.connectAuthPromise = (async () => {
       const address = await this.sdk.connectAccount(
         state.provider,
         validChainId
       );
       this.connectedAddress = address;
       this.connectedChainId = validChainId;
+    })();
+    try {
+      await this.connectAuthPromise;
+      logTiming("connectAuth success", startedAt, { chainId: validChainId });
+    } finally {
+      this.connectAuthPromise = null;
     }
   }
   /** Full connect: SIWE auth + Safe deploy check + session key. */
   async connectFull(state, chainId) {
+    const startedAt = Date.now();
     await this.connectAuth(state, chainId);
     const validChainId = isValidChainId(chainId);
     const address = this.getAddress();
+    const walletLookupStart = Date.now();
     const wallet = await this.sdk.getSmartWalletAddress(address, validChainId);
+    logTiming("connectFull getSmartWalletAddress", walletLookupStart, {
+      chainId: validChainId
+    });
+    this.smartWalletCache.set(`${address}_${validChainId}`, wallet.address);
     if (!wallet.isDeployed) {
+      const deployStart = Date.now();
       await this.sdk.deploySafe(address, validChainId, "aggressive", true);
+      logTiming("connectFull deploySafe", deployStart, {
+        chainId: validChainId
+      });
     }
+    const userDetailsStart = Date.now();
     const user = await this.sdk.getUserDetails();
+    logTiming("connectFull getUserDetails", userDetailsStart, {
+      chainId: validChainId
+    });
     if (!user.hasActiveSessionKey) {
+      const sessionKeyStart = Date.now();
       await this.sdk.createSessionKey(address, validChainId);
+      logTiming("connectFull createSessionKey", sessionKeyStart, {
+        chainId: validChainId
+      });
     }
+    logTiming("connectFull success", startedAt, { chainId: validChainId });
   }
   /** Connect + resolve smart wallet address for read operations. */
   async resolveSmartWallet(state, chainId) {
+    const startedAt = Date.now();
     await this.connectAuth(state, chainId);
     const validChainId = isValidChainId(chainId);
-    const { address } = await this.sdk.getSmartWalletAddress(
-      this.getAddress(),
-      validChainId
-    );
-    return { smartWallet: address, chainId: validChainId };
+    const ownerAddress = this.getAddress();
+    const cacheKey = `${ownerAddress}_${validChainId}`;
+    let smartWallet = this.smartWalletCache.get(cacheKey);
+    if (!smartWallet) {
+      const lookupStart = Date.now();
+      const { address } = await this.sdk.getSmartWalletAddress(
+        ownerAddress,
+        validChainId
+      );
+      logTiming("resolveSmartWallet remote-lookup", lookupStart, {
+        chainId: validChainId
+      });
+      smartWallet = address;
+      this.smartWalletCache.set(cacheKey, smartWallet);
+    } else {
+      logTiming("resolveSmartWallet cache-hit", startedAt, {
+        chainId: validChainId
+      });
+    }
+    logTiming("resolveSmartWallet ready", startedAt, { chainId: validChainId });
+    return { smartWallet, chainId: validChainId };
   }
   // --- IAgent: Connection lifecycle ---
   async disconnect() {
     await this.sdk.disconnectAccount();
     this.connectedAddress = null;
     this.connectedChainId = null;
+    this.smartWalletCache.clear();
   }
   // --- IAgent: Account lifecycle ---
   async activateAgent(state, chainId) {
     try {
-      await this.connectFull(state, chainId);
+      await this.connectAuth(state, chainId);
     } catch (error) {
       await this.disconnect();
       throw error;
@@ -312,10 +462,15 @@ var ZyfaiAgent = class {
   }
   // --- IAgent: Portfolio reads ---
   async getBalances(state, chainId) {
-    await this.connectAuth(state, chainId);
-    const validChainId = isValidChainId(chainId);
-    const raw = await this.sdk.getPositions(this.getAddress(), validChainId);
-    return mapBalances(raw, validChainId);
+    const startedAt = Date.now();
+    const { smartWallet, chainId: validChainId } = await this.resolveSmartWallet(state, chainId);
+    const portfolioStart = Date.now();
+    const raw = await this.sdk.getPortfolio(this.getAddress());
+    logTiming("getBalances getPortfolio", portfolioStart, {
+      chainId: validChainId
+    });
+    logTiming("getBalances success", startedAt, { chainId: validChainId });
+    return mapBalances(raw, validChainId, smartWallet);
   }
   async getEarnings(state, chainId) {
     const { smartWallet } = await this.resolveSmartWallet(state, chainId);
@@ -349,11 +504,13 @@ var ZyfaiAgent = class {
     return mapUserProfile(raw, this.connectedAddress);
   }
   // --- IAgent: Discovery (no wallet required) ---
-  async getAgentApy(days) {
+  async getAgentApy(days, options) {
     const raw = await this.sdk.getAPYPerStrategy(
       false,
       DayFilterMapping[days],
-      "aggressive"
+      "aggressive",
+      options?.chainId,
+      options?.tokenSymbol
     );
     return mapApyByStrategy(raw);
   }
@@ -399,9 +556,11 @@ function mapEarnings2(raw, smartWallet) {
   };
 }
 function mapApyHistory2(raw, walletAddress) {
+  const apyPerAsset = remapApyPerAssetToSymbols(raw.result.apy_per_asset);
   return {
     walletAddress,
-    weightedApyAfterFee: raw.result
+    weightedApyAfterFee: raw.result.apy,
+    weightedApyAfterFeeDetails: apyPerAsset ? { apyPerAsset } : void 0
   };
 }
 function mapSailTransaction(tx) {
@@ -535,15 +694,45 @@ function mapUserProfile2(raw) {
   };
 }
 function mapApyByStrategy2(raw) {
+  const apyPerAsset = remapApyPerAssetToSymbols(raw.result.apy_per_asset);
   return {
-    averageApy: raw.result
+    averageApy: raw.result.apy,
+    detailedApys: apyPerAsset ? { apyPerAsset } : void 0
   };
 }
+function remapApyPerAssetToSymbols(raw) {
+  if (!raw)
+    return void 0;
+  const remapped = {};
+  for (const asset of SupportedAssets) {
+    const chainKey = asset.chainId;
+    const apyByAddress = raw[String(chainKey)];
+    if (!apyByAddress)
+      continue;
+    const apy = apyByAddress[asset.address] ?? apyByAddress[asset.address.toLowerCase()];
+    if (apy === void 0)
+      continue;
+    const bucket = remapped[chainKey] ?? {};
+    bucket[asset.symbol] = apy;
+    remapped[chainKey] = bucket;
+  }
+  return Object.keys(remapped).length > 0 ? remapped : void 0;
+}
 
 // src/agents/sail/sail.agent.ts
 var SAIL_API_BASE = "https://app.sail.money";
 var PROJECT_ID = "sail";
 var PAGE_ID = "home";
+var SAIL_TIMING_PREFIX = "[AgentTiming][sail]";
+var SAIL_PORTFOLIO_TIMEOUT_MS = 8e3;
+function logTiming2(label, startedAt, meta) {
+  const elapsedMs = Date.now() - startedAt;
+  if (meta) {
+    console.log(`${SAIL_TIMING_PREFIX} ${label} ${elapsedMs}ms`, meta);
+    return;
+  }
+  console.log(`${SAIL_TIMING_PREFIX} ${label} ${elapsedMs}ms`);
+}
 var SailAgent = class {
   id = "sail";
   supportedChainIds = [8453, 42161];
@@ -565,11 +754,12 @@ var SailAgent = class {
   connectedAddress = null;
   smartWalletAddress = null;
   connectedChainId = null;
+  connectPromise = null;
   constructor(apiKey) {
     this.apiKey = apiKey;
   }
   // --- Private helpers ---
-  async request(method, path, body) {
+  async request(method, path, body, timeoutMs) {
     const headers = {
       "Content-Type": "application/json",
       "X-Business-API-Key": this.apiKey
@@ -580,32 +770,57 @@ var SailAgent = class {
     if (this.accountToken) {
       headers["X-Account-Token"] = this.accountToken;
     }
-    const res = await fetch(`${SAIL_API_BASE}${path}`, {
-      method,
-      headers,
-      body: body ? JSON.stringify(body) : void 0
-    });
+    const controller = new AbortController();
+    const timeoutId = typeof timeoutMs === "number" && timeoutMs > 0 ? setTimeout(() => controller.abort(), timeoutMs) : null;
+    let res;
+    try {
+      res = await fetch(`${SAIL_API_BASE}${path}`, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError" && timeoutMs) {
+        throw new OwneyError(
+          "API_SAIL_TIMEOUT",
+          `Sail API timeout ${timeoutMs}ms: ${method} ${path}`,
+          { timeoutMs, method, path }
+        );
+      }
+      throw error;
+    } finally {
+      if (timeoutId)
+        clearTimeout(timeoutId);
+    }
     if (!res.ok) {
       const text = await res.text().catch(() => "");
-      throw new Error(`Sail API error ${res.status}: ${text}`);
+      throw new OwneyError(
+        "API_SAIL_ERROR",
+        `Sail API error ${res.status}: ${text}`,
+        { statusCode: res.status, method, path, responseBody: text }
+      );
     }
     return res.json();
   }
   /** Initiate SIWE and sign with the user's wallet. */
   async signSiwe(state, chainId) {
+    const startedAt = Date.now();
     const initiate = await this.request(
       "POST",
       `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/auth/initiate`,
       {
         method: "siwe",
         address: state.walletAddress,
-        chainId
+        chainId,
+        identityMode: "byWallet"
       }
     );
     const signature = await state.provider.request({
       method: "personal_sign",
       params: [initiate.message, state.walletAddress]
     });
+    logTiming2("signSiwe success", startedAt, { chainId });
     return {
       sessionId: initiate.sessionId,
       message: initiate.message,
@@ -614,38 +829,62 @@ var SailAgent = class {
   }
   /** Full connect: auth handles smart account creation via SIWE flow. */
   async connectFull(state, chainId) {
+    const startedAt = Date.now();
     if (this.connectedAddress && this.connectedChainId === chainId) {
+      logTiming2("connectFull cache-hit", startedAt, { chainId });
+      return;
+    }
+    if (this.connectPromise) {
+      await this.connectPromise;
+      logTiming2("connectFull awaited-inflight", startedAt, { chainId });
       return;
     }
     if (!state.walletAddress) {
-      throw new Error("Wallet address is required");
+      throw new OwneyError(
+        "WALLET_ADDRESS_REQUIRED",
+        "Wallet address is required. Call sdk.connect(provider) first."
+      );
+    }
+    this.connectPromise = (async () => {
+      const { sessionId, signature, message } = await this.signSiwe(
+        state,
+        chainId
+      );
+      const complete = await this.request(
+        "POST",
+        `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/auth/complete`,
+        {
+          method: "custom",
+          sessionId,
+          signature,
+          walletAddress: state.walletAddress,
+          identityMode: "byWallet"
+        }
+      );
+      this.authToken = complete.token;
+      this.accountToken = complete.accountToken;
+      this.connectedAddress = state.walletAddress;
+      this.smartWalletAddress = complete.walletAddress;
+      this.connectedChainId = chainId;
+    })();
+    try {
+      await this.connectPromise;
+      logTiming2("connectFull success", startedAt, { chainId });
+    } finally {
+      this.connectPromise = null;
     }
-    const { sessionId, signature, message } = await this.signSiwe(
-      state,
-      chainId
-    );
-    const complete = await this.request(
-      "POST",
-      `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/auth/complete`,
-      {
-        method: "custom",
-        sessionId,
-        signature,
-        walletAddress: state.walletAddress
-      }
-    );
-    this.authToken = complete.token;
-    this.accountToken = complete.accountToken;
-    this.connectedAddress = state.walletAddress;
-    this.smartWalletAddress = complete.walletAddress;
-    this.connectedChainId = chainId;
   }
   async resolveSmartWallet(state, chainId) {
+    const startedAt = Date.now();
     await this.connectFull(state, chainId);
     const validChainId = isValidChainId(chainId);
     if (!this.smartWalletAddress) {
-      throw new Error("Wallet not connected. Call sdk.connect() first.");
+      throw new OwneyError(
+        "NOT_CONNECTED",
+        "Wallet not connected. Call sdk.connect() first."
+      );
     }
+    logTiming2("resolveSmartWallet ready", startedAt, { chainId: validChainId });
     return {
       smartWallet: this.smartWalletAddress,
       chainId: validChainId
@@ -670,7 +909,8 @@ var SailAgent = class {
   }
   async deposit(state, chainId, amount, depositCallback) {
     if (!depositCallback) {
-      throw new Error(
+      throw new OwneyError(
+        "DEPOSIT_CALLBACK_REQUIRED",
         "depositCallback is required for Sail. Provide a callback that transfers tokens and returns the transaction hash."
       );
     }
@@ -679,12 +919,16 @@ var SailAgent = class {
       const depositInfo = await this.getDepositInfo();
       const resolvedTokenAddress = depositInfo.permittedTokens[0]?.address;
       if (!resolvedTokenAddress) {
-        throw new Error("No permitted tokens available for deposit.");
+        throw new OwneyError(
+          "DEPOSIT_NO_PERMITTED_TOKENS",
+          "No permitted tokens available for deposit."
+        );
       }
       await this.executePreHooks(resolvedTokenAddress, amount, chainId);
       const txHash = await depositCallback(smartWallet, chainId, amount);
       if (!txHash) {
-        throw new Error(
+        throw new OwneyError(
+          "DEPOSIT_CALLBACK_INVALID",
           "depositCallback must return a transaction hash (txHash) for Sail deposits."
         );
       }
@@ -738,7 +982,10 @@ var SailAgent = class {
     const withdrawInfo = await this.getWithdrawInfo();
     const tokenAddress = withdrawInfo.permittedTokens[0]?.address;
     if (!tokenAddress) {
-      throw new Error("No permitted tokens available for withdrawal.");
+      throw new OwneyError(
+        "WITHDRAW_NO_PERMITTED_TOKENS",
+        "No permitted tokens available for withdrawal."
+      );
     }
     const resolvedAmount = amount ?? withdrawInfo.currentBalance;
     const { signature: adminWalletSignature, message: adminWalletPayload } = await this.signSiwe(state, chainId);
@@ -762,9 +1009,30 @@ var SailAgent = class {
   }
   // --- IAgent: Portfolio reads ---
   async getBalances(state, chainId) {
+    const startedAt = Date.now();
     const { smartWallet } = await this.resolveSmartWallet(state, chainId);
-    const raw = await this.getMetricsPortfolio(state, chainId);
-    return mapPortfolioBalances(raw, smartWallet);
+    const portfolioStart = Date.now();
+    try {
+      const raw = await this.getMetricsPortfolio(state, chainId);
+      logTiming2("getBalances getMetricsPortfolio", portfolioStart, { chainId });
+      logTiming2("getBalances success", startedAt, { chainId });
+      return mapPortfolioBalances(raw, smartWallet);
+    } catch (error) {
+      if (error instanceof OwneyError && error.code === "API_SAIL_TIMEOUT") {
+        console.warn(
+          "Sail portfolio request timed out; using empty snapshot.",
+          {
+            chainId
+          }
+        );
+        logTiming2("getBalances timeout-fallback", startedAt, { chainId });
+        return mapPortfolioBalances(
+          { message: "timeout", result: [] },
+          smartWallet
+        );
+      }
+      throw error;
+    }
   }
   async getEarnings(state, chainId) {
     const { smartWallet } = await this.resolveSmartWallet(state, chainId);
@@ -785,7 +1053,9 @@ var SailAgent = class {
     const { smartWallet } = await this.resolveSmartWallet(state, chainId);
     return this.request(
       "GET",
-      `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/metrics/portfolio?${smartWallet ? `smart_account=${smartWallet}` : ""}`
+      `/api/v1/projects/${PROJECT_ID}/pages/${PAGE_ID}/metrics/portfolio?${smartWallet ? `smart_account=${smartWallet}` : ""}`,
+      void 0,
+      SAIL_PORTFOLIO_TIMEOUT_MS
     );
   }
   async getMetricsEarnings(state, chainId) {
@@ -832,8 +1102,10 @@ var SailAgent = class {
     }
     const dayCount = DayFilterMapping[days];
     if (dayCount === void 0) {
-      throw new Error(
-        `Invalid days value: "${days}". Expected one of: "7D", "14D", "30D".`
+      throw new OwneyError(
+        "VALIDATION_INVALID_DAYS",
+        `Invalid days value: "${days}". Expected one of: "7D", "14D", "30D".`,
+        { days }
       );
     }
     const now = /* @__PURE__ */ new Date();
@@ -904,43 +1176,12 @@ var SailAgent = class {
     return mapUserProfile2(raw);
   }
   // --- IAgent: Discovery (no wallet required) ---
-  async getAgentApy(days) {
+  async getAgentApy(days, _options) {
     const raw = await this.getMetricsYield(days);
     return mapApyByStrategy2(raw);
   }
 };
 
-// src/errors.ts
-var AgentNotFoundError = class extends Error {
-  constructor(agentId, available) {
-    super(
-      `Unknown agent "${agentId}". Available agents: ${available.join(", ")}`
-    );
-    this.name = "AgentNotFoundError";
-  }
-};
-var NotConnectedError = class extends Error {
-  constructor() {
-    super("Not connected. Call sdk.connect(provider) first.");
-    this.name = "NotConnectedError";
-  }
-};
-var AgentChainIncompatibleError = class extends Error {
-  incompatibleAgents;
-  connectedChainId;
-  constructor(incompatibleAgents, connectedChainId) {
-    const details = incompatibleAgents.map(
-      ({ agentId, supportedChainIds }) => `"${agentId}" supports chains [${supportedChainIds.join(", ")}]`
-    ).join("; ");
-    super(
-      `Chain ${connectedChainId} is not supported by the following agents: ${details}`
-    );
-    this.name = "AgentChainIncompatibleError";
-    this.incompatibleAgents = incompatibleAgents;
-    this.connectedChainId = connectedChainId;
-  }
-};
-
 // src/lib/routing-api.ts
 var ROUTING_API_BASE_URL = "https://owney-routing-api-243946518160.europe-west4.run.app";
 async function fetchAgentKeys(apiKey) {
@@ -954,11 +1195,19 @@ async function fetchAgentKeys(apiKey) {
   });
   if (!res.ok) {
     const text = await res.text().catch(() => "");
-    throw new Error(`Routing API error ${res.status}: ${text}`);
+    throw new OwneyError(
+      "API_ROUTING_ERROR",
+      `Routing API error ${res.status}: ${text}`,
+      { statusCode: res.status, responseBody: text }
+    );
   }
   const json = await res.json();
   if (!json.success) {
-    throw new Error(`Routing API request failed: ${json.message}`);
+    throw new OwneyError(
+      "API_ROUTING_FAILED",
+      `Routing API request failed: ${json.message}`,
+      { message: json.message }
+    );
   }
   return json.data;
 }
@@ -968,11 +1217,21 @@ var AGENT_CONSTRUCTORS = {
   zyfai: ZyfaiAgent,
   sail: SailAgent
 };
+var SDK_TIMING_PREFIX = "[OwneySDKTiming]";
+function logTiming3(label, startedAt, meta) {
+  const elapsedMs = Date.now() - startedAt;
+  if (meta) {
+    console.log(`${SDK_TIMING_PREFIX} ${label} ${elapsedMs}ms`, meta);
+    return;
+  }
+  console.log(`${SDK_TIMING_PREFIX} ${label} ${elapsedMs}ms`);
+}
 var OwneySDK = class {
   agents = /* @__PURE__ */ new Map();
   activeAgents = /* @__PURE__ */ new Set();
   state = null;
   apiKey;
+  initializingAgentsPromise = null;
   constructor(config) {
     this.apiKey = config.apiKey;
   }
@@ -988,7 +1247,8 @@ var OwneySDK = class {
     });
     const walletAddress = accounts[0];
     if (!walletAddress) {
-      throw new Error(
+      throw new OwneyError(
+        "WALLET_NO_ACCOUNTS",
         "No accounts found. Ensure the wallet is unlocked and connected."
       );
     }
@@ -1027,7 +1287,8 @@ var OwneySDK = class {
   requireChainId() {
     const chainId = this.state?.chainId ?? null;
     if (chainId === null) {
-      throw new Error(
+      throw new OwneyError(
+        "NO_ACTIVE_CHAIN",
         "No active chain. Call sdk.activateAgent(chainId) first."
       );
     }
@@ -1049,6 +1310,33 @@ var OwneySDK = class {
     }
     return active;
   }
+  async ensureAgentsInitialized() {
+    if (this.agents.size > 0)
+      return;
+    if (!this.initializingAgentsPromise) {
+      this.initializingAgentsPromise = (async () => {
+        const agentKeys = await fetchAgentKeys(this.apiKey);
+        for (const { key, agent_type } of agentKeys) {
+          const AgentClass = AGENT_CONSTRUCTORS[agent_type];
+          if (!AgentClass)
+            continue;
+          const agent = new AgentClass(key);
+          this.agents.set(agent_type, agent);
+        }
+        if (this.agents.size === 0) {
+          throw new OwneyError(
+            "API_NO_AGENTS",
+            "No supported agents returned by the routing API. Check your API key and routing configuration."
+          );
+        }
+      })();
+    }
+    try {
+      await this.initializingAgentsPromise;
+    } finally {
+      this.initializingAgentsPromise = null;
+    }
+  }
   // --- Account lifecycle ---
   /**
    * Activate the user's smart wallet for the specified agents, or all chain-compatible agents if omitted.
@@ -1061,25 +1349,13 @@ var OwneySDK = class {
    *   throws before activating any agent.
    */
   async activateAgent(chainId, agentId) {
+    const startedAt = Date.now();
     const state = this.requireState();
-    if (this.agents.size === 0) {
-      const agentKeys = await fetchAgentKeys(this.apiKey);
-      for (const { key, agent_type } of agentKeys) {
-        const AgentClass = AGENT_CONSTRUCTORS[agent_type];
-        if (!AgentClass)
-          continue;
-        const agent = new AgentClass(key);
-        this.agents.set(agent_type, agent);
-      }
-      if (this.agents.size === 0) {
-        throw new Error(
-          "No supported agents returned by the routing API. Check your API key and routing configuration."
-        );
-      }
-    }
+    await this.ensureAgentsInitialized();
     if (agentId !== void 0) {
       if (agentId.length === 0) {
-        throw new Error(
+        throw new OwneyError(
+          "AGENT_EMPTY_LIST",
           "agentId array must not be empty. Omit the argument to activate all compatible agents."
         );
       }
@@ -1094,30 +1370,60 @@ var OwneySDK = class {
       if (incompatibleAgents.length > 0) {
         throw new AgentChainIncompatibleError(incompatibleAgents, chainId);
       }
-      for (const agent of agents) {
-        await agent.activateAgent(state, chainId);
-      }
       this.activeAgents.clear();
       for (const id of uniqueIds) {
         this.activeAgents.add(id);
       }
       state.chainId = chainId;
+      Promise.all(
+        agents.map(async (agent) => {
+          const agentStart = Date.now();
+          await agent.activateAgent(state, chainId);
+          logTiming3("activateAgent background-agent-ready", agentStart, {
+            chainId,
+            agentId: agent.id
+          });
+        })
+      ).catch((error) => {
+        console.error("activateAgent background init failed:", error);
+      });
+      logTiming3("activateAgent scheduled", startedAt, {
+        chainId,
+        agentIds: uniqueIds
+      });
       return;
     }
     const compatible = [...this.agents.values()].filter(
       (agent) => agent.supportedChainIds.includes(chainId)
     );
     if (compatible.length === 0) {
-      throw new Error(`No agents support chain ${chainId}.`);
-    }
-    for (const agent of compatible) {
-      await agent.activateAgent(state, chainId);
+      throw new OwneyError(
+        "CHAIN_NO_COMPATIBLE_AGENTS",
+        `No agents support chain ${chainId}.`,
+        { chainId }
+      );
     }
     this.activeAgents.clear();
     for (const agent of compatible) {
       this.activeAgents.add(agent.id);
     }
     state.chainId = chainId;
+    Promise.all(
+      compatible.map(async (agent) => {
+        const agentStart = Date.now();
+        await agent.activateAgent(state, chainId);
+        logTiming3("activateAgent background-agent-ready", agentStart, {
+          chainId,
+          agentId: agent.id
+        });
+      })
+    ).catch((error) => {
+      console.error("activateAgent background init failed:", error);
+    });
+    logTiming3("activateAgent scheduled", startedAt, {
+      chainId,
+      agentIds: compatible.map((agent) => agent.id)
+    });
   }
   /**
    * Deposit funds into a specific agent, or split equally across all agents if agentId is omitted.
@@ -1143,8 +1449,10 @@ var OwneySDK = class {
     const eligibleAgents = this.getEligibleAgents(chainId, asset);
     const totalAmount = BigInt(amount);
     if (totalAmount < BigInt(eligibleAgents.length)) {
-      throw new Error(
-        `Amount "${amount}" is too small to split across ${eligibleAgents.length} agents.`
+      throw new OwneyError(
+        "DEPOSIT_AMOUNT_TOO_SMALL",
+        `Amount "${amount}" is too small to split across ${eligibleAgents.length} agents.`,
+        { amount, agentCount: eligibleAgents.length }
       );
     }
     const perAgent = totalAmount / BigInt(eligibleAgents.length);
@@ -1167,8 +1475,10 @@ var OwneySDK = class {
       (sa) => sa.chainId === chainId
     );
     if (!chainAssets || !chainAssets.assets.includes(asset)) {
-      throw new Error(
-        `Agent "${agent.id}" does not support asset "${asset}" on chain ${chainId}.`
+      throw new OwneyError(
+        "ASSET_UNSUPPORTED",
+        `Agent "${agent.id}" does not support asset "${asset}" on chain ${chainId}.`,
+        { agentId: agent.id, asset, chainId }
       );
     }
   }
@@ -1180,8 +1490,10 @@ var OwneySDK = class {
       return chainAssets && chainAssets.assets.includes(asset);
     });
     if (eligible.length === 0) {
-      throw new Error(
-        `No agents support asset "${asset}" on chain ${chainId}.`
+      throw new OwneyError(
+        "ASSET_NO_COMPATIBLE_AGENTS",
+        `No agents support asset "${asset}" on chain ${chainId}.`,
+        { asset, chainId }
       );
     }
     return eligible;
@@ -1206,10 +1518,25 @@ var OwneySDK = class {
       return agent.withdraw(state, chainId, amount);
     }
     const eligibleAgents = this.getEligibleAgents(chainId, asset);
+    if (!amount) {
+      const results2 = {};
+      for (const agent of eligibleAgents) {
+        results2[agent.id] = await agent.withdraw(state, chainId);
+      }
+      return { agentResult: results2 };
+    }
     const results = {};
+    let lastError;
     for (const agent of eligibleAgents) {
-      results[agent.id] = await agent.withdraw(state, chainId, amount);
+      try {
+        results[agent.id] = await agent.withdraw(state, chainId, amount);
+        return { agentResult: results };
+      } catch (err) {
+        lastError = err;
+      }
     }
+    if (lastError)
+      throw lastError;
     return {
       agentResult: results
     };
@@ -1221,17 +1548,50 @@ var OwneySDK = class {
    * @returns {AgentBalance} for a single agent, or {OwneyBalances} with totalBalance and per-agent breakdown
    */
   async getBalances(agentId) {
+    const startedAt = Date.now();
     const state = this.requireState();
     const chainId = this.requireChainId();
     if (agentId) {
-      return this.getAgent(agentId).getBalances(state, chainId);
+      const result = await this.getAgent(agentId).getBalances(state, chainId);
+      logTiming3("getBalances single-agent", startedAt, { chainId, agentId });
+      return result;
     }
     let totalBalance = 0;
     const results = {};
-    for (const [id, agent] of this.getActiveAgents()) {
-      results[id] = await agent.getBalances(state, chainId);
-      totalBalance = totalBalance + Number(results[id].totalBalance);
+    const entries = [...this.getActiveAgents().entries()];
+    const balanceResults = await Promise.allSettled(
+      entries.map(async ([id, agent]) => {
+        const agentStartedAt = Date.now();
+        const b = await agent.getBalances(state, chainId);
+        logTiming3("getBalances per-agent", agentStartedAt, {
+          chainId,
+          agentId: id
+        });
+        return [id, b];
+      })
+    );
+    let successCount = 0;
+    for (const settledResult of balanceResults) {
+      if (settledResult.status === "fulfilled") {
+        const [id, b] = settledResult.value;
+        results[id] = b;
+        totalBalance += Number(b.totalBalance);
+        successCount += 1;
+        continue;
+      }
+      console.error("getBalances agent failed:", settledResult.reason);
+    }
+    if (successCount === 0) {
+      throw new OwneyError(
+        "BALANCE_ALL_FAILED",
+        "Failed to fetch balances for all active agents."
+      );
     }
+    logTiming3("getBalances aggregate", startedAt, {
+      chainId,
+      totalAgents: entries.length,
+      successCount
+    });
     return {
       totalBalance: String(totalBalance),
       agentBalances: results
@@ -1250,9 +1610,16 @@ var OwneySDK = class {
     }
     let totalEarnings = 0;
     const results = {};
-    for (const [id, agent] of this.getActiveAgents()) {
-      results[id] = await agent.getEarnings(state, chainId);
-      totalEarnings = totalEarnings + Number(results[id].lifetimeEarnings);
+    const entries = [...this.getActiveAgents().entries()];
+    const earningsResults = await Promise.all(
+      entries.map(async ([id, agent]) => {
+        const e = await agent.getEarnings(state, chainId);
+        return [id, e];
+      })
+    );
+    for (const [id, e] of earningsResults) {
+      results[id] = e;
+      totalEarnings += Number(e.lifetimeEarnings);
     }
     return {
       totalEarnings: String(totalEarnings),
@@ -1277,16 +1644,30 @@ var OwneySDK = class {
       return this.getAgent(agentId).getAccountApy(state, chainId, days);
     }
     const activeAgents = this.getActiveAgents();
+    const entries = [...activeAgents.entries()];
+    const [apyResults, balanceResults] = await Promise.all([
+      Promise.all(
+        entries.map(async ([id, agent]) => {
+          const apy = await agent.getAccountApy(state, chainId, days);
+          return [id, apy];
+        })
+      ),
+      Promise.all(
+        entries.map(async ([id, agent]) => {
+          const b = await agent.getBalances(state, chainId);
+          return [id, Number(b.totalBalance)];
+        })
+      )
+    ]);
     const results = {};
-    for (const [id, agent] of activeAgents) {
-      results[id] = await agent.getAccountApy(state, chainId, days);
+    for (const [id, apy] of apyResults) {
+      results[id] = apy;
     }
     const balances = {};
     let totalBalance = 0;
-    for (const [id, agent] of activeAgents) {
-      const b = await agent.getBalances(state, chainId);
-      balances[id] = Number(b.totalBalance);
-      totalBalance += balances[id];
+    for (const [id, bal] of balanceResults) {
+      balances[id] = bal;
+      totalBalance += bal;
     }
     let totalApy = 0;
     if (totalBalance > 0) {
@@ -1314,9 +1695,13 @@ var OwneySDK = class {
     if (agentId) {
       return this.getAgent(agentId).getHistory(state, chainId, filters);
     }
+    const historyResults = await Promise.all(
+      [...this.getActiveAgents().values()].map(
+        (agent) => agent.getHistory(state, chainId, filters)
+      )
+    );
     let results = [];
-    for (const [, agent] of this.getActiveAgents()) {
-      const { data } = await agent.getHistory(state, chainId, filters);
+    for (const { data } of historyResults) {
       results = [...results, ...data];
     }
     results.sort(
@@ -1360,8 +1745,15 @@ var OwneySDK = class {
       return this.getAgent(agentId).getUserProfile(state, chainId);
     }
     const results = {};
-    for (const [id, agent] of this.getActiveAgents()) {
-      results[id] = await agent.getUserProfile(state, chainId);
+    const entries = [...this.getActiveAgents().entries()];
+    const profileResults = await Promise.all(
+      entries.map(async ([id, agent]) => {
+        const p = await agent.getUserProfile(state, chainId);
+        return [id, p];
+      })
+    );
+    for (const [id, p] of profileResults) {
+      results[id] = p;
     }
     return {
       agentUserProfile: results
@@ -1373,18 +1765,34 @@ var OwneySDK = class {
    * @param options - Contains agentId (optional) and days ("7D", "14D", or "30D")
    * @param options.agentId - Optional. Agent to query. Omit for all agents.
    * @param options.days - Lookback period: "7D", "14D", or "30D"
+   * @param options.tokenSymbol - Optional asset symbol ("USDC" / "WETH") to
+   *   scope the APY to a specific asset+chain. Agents whose backends do not
+   *   support per-asset APY (currently Sail) ignore this.
+   * @param options.chainId - Optional chain id for per-asset APY lookups.
+   *   Typically paired with `tokenSymbol`.
    * @returns {AgentApy} for a single agent, or {OwneyAgentApy} with per-agent APY
    */
   async getAgentApy({
     agentId,
-    days
+    days,
+    tokenSymbol,
+    chainId
   }) {
+    await this.ensureAgentsInitialized();
+    const agentOptions = { tokenSymbol, chainId };
     if (agentId) {
-      return this.getAgent(agentId).getAgentApy(days);
+      return this.getAgent(agentId).getAgentApy(days, agentOptions);
     }
     const results = {};
-    for (const [id, agent] of this.agents) {
-      results[id] = await agent.getAgentApy(days);
+    const agentEntries = [...this.agents.entries()];
+    const apyResults = await Promise.all(
+      agentEntries.map(async ([id, agent]) => {
+        const apy = await agent.getAgentApy(days, agentOptions);
+        return [id, apy];
+      })
+    );
+    for (const [id, apy] of apyResults) {
+      results[id] = apy;
     }
     return {
       agentApy: results
@@ -1400,10 +1808,29 @@ var OwneySDK = class {
     const activeAgents = this.getActiveAgents();
     const balances = {};
     let totalBalance = 0;
-    for (const [id, agent] of activeAgents) {
-      const b = await agent.getBalances(state, chainId);
-      balances[id] = Number(b.totalBalance);
-      totalBalance += balances[id];
+    const entries = [...activeAgents.entries()];
+    const balanceResults = await Promise.allSettled(
+      entries.map(async ([id, agent]) => {
+        const b = await agent.getBalances(state, chainId);
+        return [id, Number(b.totalBalance)];
+      })
+    );
+    let successCount = 0;
+    for (const settledResult of balanceResults) {
+      if (settledResult.status === "fulfilled") {
+        const [id, bal] = settledResult.value;
+        balances[id] = bal;
+        totalBalance += bal;
+        successCount += 1;
+      } else {
+        console.error("getAgentAllocation agent failed:", settledResult.reason);
+      }
+    }
+    if (successCount === 0) {
+      throw new OwneyError(
+        "ALLOCATION_ALL_FAILED",
+        "Failed to fetch allocation: all agents failed."
+      );
     }
     const allocation = {};
     if (totalBalance === 0) {
@@ -1431,5 +1858,6 @@ export {
   AgentChainIncompatibleError,
   AgentNotFoundError,
   NotConnectedError,
+  OwneyError,
   OwneySDK
 };