@elizaos/plugin-wallet 2.0.0-beta.1

package/src/analytics/lpinfo/index.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from "@elizaos/core";
+
+export declare const lpinfoPlugin: Plugin;
+export default lpinfoPlugin;
+
+export * from "./steer";
+export * from "./kamino";

package/src/analytics/lpinfo/index.ts

@@ -0,0 +1,52 @@
+// @ts-nocheck — legacy code from absorbed plugins (lp-manager, lpinfo, dexscreener, defi-news, birdeye); strict types pending cleanup
+import type { Plugin } from "@elizaos/core";
+// Kamino Protocol Plugin
+import { kaminoPlugin } from "./kamino";
+// Steer Finance Plugin
+import { steerPlugin } from "./steer";
+
+/**
+ * Liquidity Pool Information Plugin
+ *
+ * A comprehensive plugin that provides liquidity pool management and analytics
+ * for multiple DeFi protocols on Solana.
+ *
+ * Supported Protocols:
+ * - Steer Finance: Vault and staking pool management
+ * - Kamino Protocol: Lending and liquidity pool management
+ *
+ * Features:
+ * - Multi-protocol liquidity pool tracking
+ * - Yield optimization analytics
+ * - Position tracking and management
+ * - Market data and statistics
+ *
+ * @author ElizaOS
+ * @version 1.0.0
+ */
+export const lpinfoPlugin: Plugin = {
+  name: "lpinfo",
+  description:
+    "Comprehensive liquidity pool information plugin supporting Steer Finance and Kamino Protocol for pool tracking, yield optimization, and position management",
+  providers: [
+    ...(steerPlugin.providers || []),
+    ...(kaminoPlugin.providers || []),
+  ],
+  actions: [...(steerPlugin.actions || []), ...(kaminoPlugin.actions || [])],
+  services: [...(steerPlugin.services || []), ...(kaminoPlugin.services || [])],
+};
+
+export default lpinfoPlugin;
+
+export { kaminoPlugin } from "./kamino";
+export * from "./kamino/providers/kaminoLiquidityProvider";
+export * from "./kamino/providers/kaminoPoolProvider";
+// Export Kamino components
+export * from "./kamino/providers/kaminoProvider";
+export * from "./kamino/services/kaminoLiquidityService";
+export * from "./kamino/services/kaminoService";
+// Re-export sub-plugins for granular control if needed
+export { steerPlugin } from "./steer";
+// Export Steer components
+export * from "./steer/providers/steerLiquidityProvider";
+export * from "./steer/services/steerLiquidityService";

package/src/analytics/lpinfo/kamino/README.md

@@ -0,0 +1,102 @@
+# Kamino Lending Protocol Plugin
+
+This plugin provides comprehensive integration with the Kamino lending protocol on Solana, allowing users to view their lending and borrowing positions, market data, and available opportunities.
+
+## Features
+
+### 📊 Position Tracking
+
+- **Lending Positions**: View all your active lending positions across Kamino markets
+- **Borrowing Positions**: Track your borrowing positions and interest rates
+- **Portfolio Value**: Calculate total portfolio value including lending and borrowing
+- **Multi-Wallet Support**: View positions for all Solana wallets in your account
+
+### 🏦 Market Data
+
+- **Available Reserves**: Browse all available lending and borrowing opportunities
+- **APY Rates**: View current supply and borrow APY rates
+- **Market Overview**: Get comprehensive market statistics and TVL data
+- **Top Opportunities**: Identify the best lending opportunities by APY
+
+### 📈 Analytics
+
+- **Market Utilization**: Track utilization rates across different markets
+- **Total Value Locked**: Monitor TVL across all Kamino markets
+- **Borrowing Activity**: View total borrowed amounts and market health
+
+## Usage
+
+The Kamino plugin is designed to work in private messages (DMs) for security. When you send a message in a DM, the plugin will automatically:
+
+1. **Extract your wallet addresses** from your connected Solana wallets
+2. **Fetch your positions** from all Kamino markets
+3. **Display a comprehensive report** including:
+   - Your lending and borrowing positions
+   - Available lending opportunities
+   - Market overview and statistics
+
+## Provider Information
+
+The plugin provides the following information through the `KAMINO_LENDING` provider:
+
+### User Positions
+
+- **Lending Positions**: Token, amount, value, APY, and market for each position
+- **Borrowing Positions**: Token, amount, value, APY, and market for each position
+- **Total Portfolio Value**: Net value of all positions
+
+### Available Reserves
+
+- **Top Lending Opportunities**: Highest APY lending options
+- **Reserve Details**: Supply/borrow APY, total supply/borrow, utilization rates
+- **Market Information**: Which market each reserve belongs to
+
+### Market Overview
+
+- **Total Markets**: Number of active Kamino markets
+- **Total TVL**: Combined total value locked across all markets
+- **Total Borrowed**: Total amount borrowed across all markets
+- **Top Markets**: Markets with highest TVL
+
+## Technical Details
+
+### Dependencies
+
+- `@solana/web3.js`: Solana blockchain interaction
+- `@hubbleprotocol/kamino-sdk`: Official Kamino SDK for protocol interaction
+
+### Environment Variables
+
+- `SOLANA_RPC_URL`: Solana RPC endpoint (defaults to mainnet-beta)
+
+### Service Architecture
+
+- **KaminoService**: Handles all Kamino protocol interactions
+- **Provider**: Formats and presents data to the agent
+- **Account Integration**: Uses existing account system for wallet management
+
+## Security
+
+- **Private Messages Only**: Position data is only available in DMs
+- **Account Verification**: Requires verified account with connected wallets
+- **No Private Keys**: Only uses public wallet addresses for queries
+
+## Error Handling
+
+The plugin includes comprehensive error handling for:
+
+- Network connectivity issues
+- Invalid wallet addresses
+- Missing account data
+- API rate limits
+- Market data unavailability
+
+## Future Enhancements
+
+Potential future features:
+
+- Position management actions (deposit, withdraw, borrow, repay)
+- Yield optimization recommendations
+- Historical position tracking
+- Risk assessment and alerts
+- Integration with other DeFi protocols

package/src/analytics/lpinfo/kamino/index.ts

@@ -0,0 +1,24 @@
+// @ts-nocheck — legacy code from absorbed plugins (lp-manager, lpinfo, dexscreener, defi-news, birdeye); strict types pending cleanup
+import type { Plugin } from "@elizaos/core";
+import { kaminoLiquidityProvider } from "./providers/kaminoLiquidityProvider";
+import { kaminoPoolProvider } from "./providers/kaminoPoolProvider";
+// Providers
+import { kaminoProvider } from "./providers/kaminoProvider";
+import { KaminoLiquidityService } from "./services/kaminoLiquidityService";
+// Services
+import { KaminoService } from "./services/kaminoService";
+
+/**
+ * Kamino Protocol Plugin
+ * Provides comprehensive access to Kamino lending and liquidity protocols
+ */
+export const kaminoPlugin: Plugin = {
+  name: "kamino-protocol",
+  description:
+    "Comprehensive Kamino protocol integration for viewing lending positions, liquidity pools, and market analytics. Supports position tracking and yield optimization.",
+  providers: [kaminoProvider, kaminoLiquidityProvider, kaminoPoolProvider],
+  actions: [],
+  services: [KaminoService, KaminoLiquidityService],
+};
+
+export default kaminoPlugin;

package/src/analytics/lpinfo/kamino/providers/kaminoLiquidityProvider.ts

@@ -0,0 +1,422 @@
+// @ts-nocheck — legacy code from absorbed plugins (lp-manager, lpinfo, dexscreener, defi-news, birdeye); strict types pending cleanup
+import type { IAgentRuntime, Memory, Provider, State } from "@elizaos/core";
+import { ModelType } from "@elizaos/core";
+import type { KaminoLiquidityService } from "../services/kaminoLiquidityService";
+
+const KAMINO_LIQUIDITY_TEXT_LIMIT = 4000;
+
+// Import the KaminoStrategy type from the service
+interface KaminoStrategy {
+  address: string;
+  dataSize: number;
+  lamports: number;
+  owner: string;
+  strategyType: string;
+  estimatedTvl: number;
+  volume24h: number;
+  apy: number;
+  tokenA: string;
+  tokenB: string;
+  feeTier: string;
+  rebalancing: string;
+  lastRebalance: string;
+  positions: unknown[];
+}
+
+function asPromptRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === "object"
+    ? (value as Record<string, unknown>)
+    : {};
+}
+
+function formatTokenInfoForPrompt(tokenInfo: unknown): string {
+  if (!tokenInfo) {
+    return "token_status: not resolved";
+  }
+
+  const token = asPromptRecord(tokenInfo);
+  const fields = [
+    ["token_status", "resolved"],
+    ["name", token.name],
+    ["symbol", token.symbol],
+    ["address", token.address],
+    ["price_usd", token.price],
+    ["liquidity_usd", token.liquidity],
+    ["market_cap_usd", token.marketCap],
+    ["volume_24h_usd", token.volume24h],
+    ["price_change_24h_percent", token.priceChange24h],
+    ["decimals", token.decimals],
+  ];
+
+  return fields
+    .filter(
+      ([, value]) => value !== undefined && value !== null && value !== "",
+    )
+    .map(([key, value]) => `${key}: ${formatPromptValue(value)}`)
+    .join("\n");
+}
+
+function formatMarketStatsForPrompt(marketStats: unknown): string {
+  if (!marketStats) {
+    return "market_status: not available";
+  }
+
+  const stats = asPromptRecord(marketStats);
+  const stakingYields = asPromptRecord(stats.stakingYields);
+  const medianYields = asPromptRecord(stats.medianYields);
+  const limoTrades = asPromptRecord(stats.limoTrades);
+
+  return [
+    "market_status: available",
+    `timestamp: ${formatPromptValue(stats.timestamp)}`,
+    `staking_yields_total: ${formatPromptValue(stakingYields.total)}`,
+    `staking_yields_average_apy: ${formatPromptValue(stakingYields.averageApy)}`,
+    `staking_yields_max_apy: ${formatPromptValue(stakingYields.maxApy)}`,
+    `staking_yields_min_apy: ${formatPromptValue(stakingYields.minApy)}`,
+    `median_yields_total: ${formatPromptValue(medianYields.total)}`,
+    `median_yields_average_apy: ${formatPromptValue(medianYields.averageApy)}`,
+    `limo_trades_total: ${formatPromptValue(limoTrades.total)}`,
+    `limo_trades_total_volume_usd: ${formatPromptValue(limoTrades.totalVolume)}`,
+    `limo_trades_average_tip_usd: ${formatPromptValue(limoTrades.averageTip)}`,
+    `limo_trades_average_surplus_usd: ${formatPromptValue(limoTrades.averageSurplus)}`,
+  ].join("\n");
+}
+
+function formatPromptValue(value: unknown): string {
+  if (value === null || value === undefined) {
+    return "N/A";
+  }
+
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? String(value) : "N/A";
+  }
+
+  if (typeof value === "string") {
+    return value;
+  }
+
+  if (typeof value === "boolean") {
+    return String(value);
+  }
+
+  return String(value);
+}
+
+/**
+ * Kamino Liquidity Protocol Provider
+ * Provides information about Kamino liquidity pools and strategies
+ */
+export const kaminoLiquidityProvider: Provider = {
+  name: "KAMINO_LIQUIDITY",
+  description:
+    "Provides information about Kamino liquidity pools, strategies, and token-specific liquidity data",
+  descriptionCompressed:
+    "provide information Kamino liquidity pool, strategy, token-specific liquidity data",
+  dynamic: true,
+  contexts: ["finance", "crypto", "wallet"],
+  contextGate: { anyOf: ["finance", "crypto", "wallet"] },
+  cacheStable: false,
+  cacheScope: "turn",
+  roleGate: { minRole: "USER" },
+  get: async (runtime: IAgentRuntime, message: Memory, _state: State) => {
+    console.log("KAMINO_LIQUIDITY provider called");
+
+    let liquidityInfo = "";
+
+    try {
+      // Extract token address from message content
+      const content = message.content.text || "";
+      const tokenMatch = content.match(/([A-Za-z0-9]{32,44})/);
+
+      let tokenIdentifier = "";
+      if (tokenMatch) {
+        tokenIdentifier = tokenMatch[1];
+      }
+
+      // Get Kamino liquidity service
+      const kaminoLiquidityService = runtime.getService(
+        "KAMINO_LIQUIDITY_SERVICE",
+      ) as KaminoLiquidityService;
+      if (!kaminoLiquidityService) {
+        liquidityInfo += "❌ Kamino liquidity service not available.\n";
+      } else {
+        if (tokenIdentifier) {
+          console.log(`Token identifier found: ${tokenIdentifier}`);
+
+          liquidityInfo += `=== KAMINO LIQUIDITY POOL STATS ===\n\n`;
+          liquidityInfo += `Token: ${tokenIdentifier}\n\n`;
+
+          // Resolve token information using Birdeye through the service
+          const tokenInfo =
+            await kaminoLiquidityService.resolveTokenWithBirdeye(
+              tokenIdentifier,
+            );
+          if (tokenInfo) {
+            liquidityInfo += `🔍 Token Resolution via Birdeye:\n`;
+            liquidityInfo += `   📝 Name: ${tokenInfo.name}\n`;
+            liquidityInfo += `   🔖 Symbol: ${tokenInfo.symbol}\n`;
+            liquidityInfo += `   🔗 Address: ${tokenInfo.address}\n`;
+            liquidityInfo += `   💵 Price: $${tokenInfo.price?.toFixed(6) || "N/A"}\n`;
+            liquidityInfo += `   💧 Liquidity: $${tokenInfo.liquidity?.toLocaleString() || "N/A"}\n`;
+            liquidityInfo += `   📊 Market Cap: $${tokenInfo.marketCap?.toLocaleString() || "N/A"}\n`;
+            liquidityInfo += `   📈 24h Change: ${tokenInfo.priceChange24h?.toFixed(2) || "N/A"}%\n\n`;
+          }
+
+          // Get liquidity pool stats for the specific token using optimized method
+          const poolStats = await getKaminoLiquidityStats(
+            kaminoLiquidityService,
+            tokenIdentifier,
+          );
+
+          // Generate enhanced response using LLM
+          const enhancedReport = await generateEnhancedKaminoLiquidityReport(
+            runtime,
+            {
+              tokenIdentifier,
+              tokenInfo,
+              poolStats,
+              kaminoLiquidityService,
+            },
+          );
+
+          liquidityInfo += enhancedReport;
+        } else {
+          // No specific token provided, show protocol overview without wasting RPC calls
+          liquidityInfo += `=== KAMINO LIQUIDITY PROTOCOL OVERVIEW ===\n\n`;
+          liquidityInfo += `🔍 Kamino Liquidity Protocol Information\n\n`;
+
+          // Use testConnection to get basic info without making expensive RPC calls
+          const testResults = await kaminoLiquidityService.testConnection();
+
+          liquidityInfo += `📊 Protocol Status:\n`;
+          liquidityInfo += `   ✅ Connection: ${testResults.connectionTest ? "Connected" : "Failed"}\n`;
+          liquidityInfo += `   📋 Program ID: ${testResults.programId}\n`;
+          liquidityInfo += `   🔗 RPC Endpoint: ${testResults.rpcEndpoint}\n`;
+          liquidityInfo += `   📈 Available Strategies: ${testResults.strategyCount}\n\n`;
+
+          // Add general Kamino liquidity protocol info
+          liquidityInfo += await getKaminoProtocolInfo(kaminoLiquidityService);
+
+          // Add usage instructions
+          liquidityInfo += `💡 How to use:\n`;
+          liquidityInfo += `   • Provide a token address to search for specific liquidity pools\n`;
+          liquidityInfo += `   • Example: "Check Kamino liquidity for HeLp6NuQkmYB4pYWo2zYs22mESHXPQYzXbB8n4V98jwC"\n`;
+          liquidityInfo += `   • Visit https://app.kamino.finance/liquidity to view all pools\n\n`;
+        }
+      }
+    } catch (error) {
+      console.error("Error in Kamino liquidity provider:", error);
+      liquidityInfo = `Error generating Kamino liquidity report: ${error instanceof Error ? error.message : "Unknown error"}`;
+    }
+
+    const data = {
+      kaminoLiquidity: liquidityInfo,
+    };
+
+    const text = `${liquidityInfo}\n`.slice(0, KAMINO_LIQUIDITY_TEXT_LIMIT);
+
+    return {
+      data,
+      values: {} as Record<string, unknown>,
+      text,
+    };
+  },
+};
+
+/**
+ * Get Kamino liquidity pool statistics for a specific token using optimized method
+ */
+async function getKaminoLiquidityStats(
+  kaminoLiquidityService: KaminoLiquidityService,
+  tokenIdentifier: string,
+): Promise<string> {
+  let statsInfo = "";
+
+  try {
+    statsInfo += `🔍 SEARCHING FOR KAMINO LIQUIDITY POOLS...\n\n`;
+
+    // Use the optimized getTokenLiquidityStats method that uses filters and getStrategyByAddress
+    const tokenStats =
+      await kaminoLiquidityService.getTokenLiquidityStats(tokenIdentifier);
+
+    if (tokenStats.strategies.length > 0) {
+      statsInfo += `📊 FOUND ${tokenStats.strategies.length} RELEVANT STRATEGIES:\n\n`;
+      statsInfo += `Token: ${tokenStats.tokenName}\n`;
+      statsInfo += `Total TVL: $${tokenStats.totalTvl.toLocaleString()}\n`;
+      statsInfo += `24h Volume: $${tokenStats.totalVolume.toLocaleString()}\n`;
+      statsInfo += `APY Range: ${tokenStats.apyRange.min.toFixed(2)}% - ${tokenStats.apyRange.max.toFixed(2)}%\n\n`;
+
+      // Group strategies by type for better organization
+      const strategyTypes = new Map<string, KaminoStrategy[]>();
+      tokenStats.strategies.forEach((strategy) => {
+        const type = strategy.strategyType;
+        if (!strategyTypes.has(type)) {
+          strategyTypes.set(type, []);
+        }
+        strategyTypes.get(type)?.push(strategy);
+      });
+
+      for (const [type, strategies] of strategyTypes) {
+        statsInfo += `🏊‍♂️ ${type.toUpperCase()} (${strategies.length} strategies):\n`;
+        const totalTvl = strategies.reduce(
+          (sum, s) => sum + (s.estimatedTvl || 0),
+          0,
+        );
+        const avgApy =
+          strategies.reduce((sum, s) => sum + (s.apy || 0), 0) /
+          strategies.length;
+        statsInfo += `   💰 Total TVL: $${totalTvl.toLocaleString()}\n`;
+        statsInfo += `   🎯 Average APY: ${avgApy.toFixed(2)}%\n\n`;
+
+        // Show details for each strategy in this type
+        for (const strategy of strategies) {
+          statsInfo += await getStrategyDetails(strategy);
+        }
+      }
+
+      // Add direct link to Kamino app for found strategies
+      statsInfo += `🔗 **View on Kamino:** https://app.kamino.finance/liquidity\n\n`;
+    } else {
+      statsInfo += `❌ No Kamino liquidity strategies found for ${tokenIdentifier}\n\n`;
+      statsInfo += `🔍 Analysis Results:\n`;
+      statsInfo += `   • Token: ${tokenStats.tokenName}\n`;
+      statsInfo += `   • Searched through Kamino liquidity program with optimized filters\n`;
+      statsInfo += `   • No strategies containing this token were found\n\n`;
+      statsInfo += `💡 Possible reasons:\n`;
+      statsInfo += `   • Token may not be listed on Kamino liquidity pools\n`;
+      statsInfo += `   • Token might be too new or have low liquidity\n`;
+      statsInfo += `   • Token may be listed under a different address\n`;
+      statsInfo += `   • Token might be in a different strategy type\n\n`;
+      statsInfo += `🔗 Check available strategies at: https://app.kamino.finance/liquidity\n`;
+    }
+
+    // Add general Kamino liquidity protocol info
+    statsInfo += await getKaminoProtocolInfo(kaminoLiquidityService);
+  } catch (error) {
+    console.error("Error getting Kamino liquidity stats:", error);
+    statsInfo += `❌ Error fetching liquidity data: ${error instanceof Error ? error.message : "Unknown error"}\n`;
+  }
+
+  return statsInfo;
+}
+
+/**
+ * Get detailed information about a specific strategy
+ */
+async function getStrategyDetails(strategy: KaminoStrategy): Promise<string> {
+  let details = `   🏊‍♂️ STRATEGY: ${strategy.address}\n`;
+  details += `      📈 Type: ${strategy.strategyType}\n`;
+  details += `      💰 TVL: $${strategy.estimatedTvl.toLocaleString()}\n`;
+  details += `      📊 24h Volume: $${strategy.volume24h.toLocaleString()}\n`;
+  details += `      🎯 APY: ${strategy.apy.toFixed(2)}%\n`;
+  details += `      🔄 Rebalancing: ${strategy.rebalancing}\n`;
+  details += `      💸 Fee Tier: ${strategy.feeTier}\n`;
+  details += `      🕒 Last Rebalance: ${new Date(strategy.lastRebalance).toLocaleDateString()}\n`;
+
+  if (strategy.positions && strategy.positions.length > 0) {
+    details += `      📍 Positions:\n`;
+    for (const position of strategy.positions) {
+      details += `         • ${position.type}: ${position.range} ($${position.liquidity.toLocaleString()})\n`;
+    }
+  }
+
+  details += `\n`;
+
+  return details;
+}
+
+/**
+ * Get general Kamino protocol information
+ */
+async function getKaminoProtocolInfo(
+  kaminoLiquidityService: KaminoLiquidityService,
+): Promise<string> {
+  let info = `🌊 KAMINO LIQUIDITY PROTOCOL INFO:\n\n`;
+
+  try {
+    const testResults = await kaminoLiquidityService.testConnection();
+
+    info += `📋 Program ID: ${testResults.programId}\n`;
+    info += `🔗 RPC Endpoint: ${testResults.rpcEndpoint}\n`;
+    info += `✅ Connection Status: ${testResults.connectionTest ? "Connected" : "Failed"}\n`;
+    info += `📊 Strategy Count: ${testResults.strategyCount}\n\n`;
+
+    info += `🔗 Useful Links:\n`;
+    info += `   • Kamino App: https://app.kamino.finance/liquidity\n`;
+    info += `   • Documentation: https://docs.kamino.finance\n`;
+    info += `   • GitHub: https://github.com/Kamino-Finance\n\n`;
+
+    info += `💡 How to use:\n`;
+    info += `   • Visit the Kamino app to view all available liquidity pools\n`;
+    info += `   • Deposit tokens to earn yield from automated market making\n`;
+    info += `   • Strategies automatically rebalance to maintain optimal positions\n`;
+  } catch (error) {
+    console.error("Error getting protocol info:", error);
+    info += `❌ Error fetching protocol information\n`;
+  }
+
+  return info;
+}
+
+/**
+ * Generate enhanced Kamino liquidity report using LLM
+ */
+async function generateEnhancedKaminoLiquidityReport(
+  runtime: IAgentRuntime,
+  data: {
+    tokenIdentifier: string;
+    tokenInfo: unknown;
+    poolStats: string;
+    kaminoLiquidityService: KaminoLiquidityService;
+  },
+): Promise<string> {
+  try {
+    // Get additional market context
+    const marketStats = await data.kaminoLiquidityService.getMarketStatistics();
+
+    // Create a focused prompt for the LLM
+    const liquidityPrompt = `You are a professional DeFi analyst specializing in Kamino Finance liquidity protocols. Generate a comprehensive, well-crafted analysis report for the token ${data.tokenIdentifier}.
+
+TOKEN INFORMATION:
+${formatTokenInfoForPrompt(data.tokenInfo)}
+
+POOL STATISTICS:
+${data.poolStats}
+
+MARKET CONTEXT:
+${formatMarketStatsForPrompt(marketStats)}
+
+Please generate a professional, engaging report that includes:
+
+1. **Token Overview** - Brief introduction to the token and its market position
+2. **Liquidity Analysis** - Detailed breakdown of Kamino liquidity pools and strategies
+3. **Performance Metrics** - TVL, APY ranges, volume analysis, and key performance indicators
+4. **Strategy Assessment** - Analysis of different strategy types (staking, Limo trading) and their effectiveness
+5. **Market Insights** - How this token's liquidity compares to market trends
+6. **Risk & Opportunity Analysis** - Key risks and opportunities for liquidity providers
+7. **Investment Recommendations** - Clear, actionable insights for potential investors
+
+Format the report with:
+- Clear sections with descriptive headers
+- Use emojis for visual appeal and quick scanning
+- Include specific numbers and percentages
+- Provide professional but engaging tone
+- Focus on actionable insights
+- Include relevant comparisons to market standards
+- End with a concise summary
+
+Make it comprehensive yet easy to read. Be specific about the data and provide clear insights about this particular token's liquidity situation on Kamino Finance.
+
+Generate a professional Kamino liquidity analysis report:`;
+
+    // Use LLM to generate the enhanced report
+    const enhancedReport = await runtime.useModel(ModelType.TEXT_LARGE, {
+      prompt: liquidityPrompt,
+    });
+
+    return enhancedReport || data.poolStats;
+  } catch (error) {
+    console.error("Error generating enhanced Kamino liquidity report:", error);
+    return data.poolStats; // Fallback to original stats
+  }
+}