@elizaos/plugin-dummy-services 1.4.2 → 1.4.3-alpha.1

package/dist/index.js

@@ -1,578 +1,607 @@
 // src/tokenData/service.ts
-import { ITokenDataService, ServiceType, logger } from "@elizaos/core";
-import { v4 as uuidv4 } from "uuid";
-var DummyTokenDataService = class _DummyTokenDataService extends ITokenDataService {
-  serviceName = "dummy-token-data";
-  static serviceType = ServiceType.TOKEN_DATA;
+import { Service, logger } from "@elizaos/core";
+
+class DummyTokenDataService extends Service {
+  static serviceType = "token_data";
+  capabilityDescription = "Dummy token data service for testing";
+  get serviceName() {
+    return "dummy-token-data";
+  }
   constructor(runtime) {
     super(runtime);
-    logger.info("DummyTokenDataService initialized");
   }
-  generateDummyToken(chain, address, query) {
-    const randomAddress = address || `0x${uuidv4().replace(/-/g, "")}`;
-    const symbol = query ? query.toUpperCase() : randomAddress.substring(2, 6).toUpperCase();
+  static async start(runtime) {
+    const service = new DummyTokenDataService(runtime);
+    await service.start();
+    return service;
+  }
+  async start() {
+    logger.info(`[${this.serviceName}] Service started.`);
+  }
+  async stop() {
+    logger.info(`[${this.serviceName}] Service stopped.`);
+  }
+  async getTokenData(tokenAddress) {
+    return {
+      symbol: "DUMMY",
+      name: "Dummy Token",
+      address: tokenAddress,
+      decimals: 18,
+      totalSupply: "1000000000",
+      priceUsd: 1.23,
+      marketCapUsd: 1230000000,
+      volume24hUsd: 45600000,
+      priceChange24h: 5.67
+    };
+  }
+  async getTokenDataBySymbol(symbol) {
+    return {
+      symbol: symbol.toUpperCase(),
+      name: `${symbol} Token`,
+      address: "0xdummy",
+      decimals: 18,
+      totalSupply: "1000000000",
+      priceUsd: 1.23,
+      marketCapUsd: 1230000000,
+      volume24hUsd: 45600000,
+      priceChange24h: 5.67
+    };
+  }
+  async getMultipleTokenData(tokenAddresses) {
+    return tokenAddresses.map((address, index) => ({
+      symbol: `TOKEN${index}`,
+      name: `Token ${index}`,
+      address,
+      decimals: 18,
+      totalSupply: "1000000000",
+      priceUsd: 1.23 * (index + 1),
+      marketCapUsd: 1230000000 * (index + 1),
+      volume24hUsd: 45600000 * (index + 1),
+      priceChange24h: 5.67 * (index % 2 === 0 ? 1 : -1)
+    }));
+  }
+  async getTokenDetails(address, chain = "solana") {
+    const symbol = address.startsWith("So") ? address.substring(2, 6) : address.substring(0, 4).toUpperCase();
     return {
-      id: `${chain}:${randomAddress}`,
+      id: `${chain}:${address}`,
       symbol,
       name: `Dummy Token ${symbol}`,
-      address: randomAddress,
+      address,
       chain,
-      sourceProvider: "dummy",
-      price: Math.random() * 100,
-      priceChange24hPercent: (Math.random() - 0.5) * 20,
-      volume24hUSD: Math.random() * 1e6,
-      marketCapUSD: Math.random() * 1e8,
-      liquidity: Math.random() * 5e5,
-      holders: Math.floor(Math.random() * 1e4),
-      logoURI: "https://via.placeholder.com/150",
       decimals: 18,
-      lastUpdatedAt: /* @__PURE__ */ new Date(),
+      totalSupply: "1000000000",
+      price: 1.23 + Math.random() * 10,
+      priceUsd: 1.23 + Math.random() * 10,
+      marketCapUsd: 1230000000 + Math.random() * 1e9,
+      marketCapUSD: 1230000000 + Math.random() * 1e9,
+      volume24hUsd: 45600000 + Math.random() * 50000000,
+      volume24hUSD: 45600000 + Math.random() * 50000000,
+      priceChange24h: -10 + Math.random() * 20,
+      priceChange24hPercent: -10 + Math.random() * 20,
+      logoURI: "https://via.placeholder.com/150",
+      liquidity: 5000000 + Math.random() * 5000000,
+      holders: Math.floor(1000 + Math.random() * 9000),
+      sourceProvider: "dummy",
+      lastUpdatedAt: new Date,
       raw: {
         dummyData: true
       }
     };
   }
-  async getTokenDetails(address, chain) {
-    logger.debug(`DummyTokenDataService: getTokenDetails for ${address} on ${chain}`);
-    return this.generateDummyToken(chain, address);
-  }
-  async getTrendingTokens(chain = "solana", limit = 10, _timePeriod = "24h") {
-    logger.debug(`DummyTokenDataService: getTrendingTokens on ${chain}`);
-    return Array.from({ length: limit }, () => this.generateDummyToken(chain));
+  async getTrendingTokens(chain = "solana", limit = 10) {
+    const tokens = [];
+    for (let i = 0;i < limit; i++) {
+      const symbol = `TREND${i + 1}`;
+      tokens.push({
+        id: `${chain}:0xtrending${i}`,
+        symbol,
+        name: `Trending Token ${i + 1}`,
+        address: `0xtrending${i}`,
+        chain,
+        decimals: 18,
+        totalSupply: "1000000000",
+        price: Math.random() * 100,
+        priceUsd: Math.random() * 100,
+        marketCapUsd: 1e6 + Math.random() * 1e9,
+        marketCapUSD: 1e6 + Math.random() * 1e9,
+        volume24hUsd: 1e5 + Math.random() * 1e7,
+        volume24hUSD: 1e5 + Math.random() * 1e7,
+        priceChange24h: -50 + Math.random() * 100,
+        priceChange24hPercent: -10 + Math.random() * 20,
+        logoURI: "https://via.placeholder.com/150",
+        liquidity: 1e6 + Math.random() * 9000000,
+        holders: Math.floor(500 + Math.random() * 9500),
+        sourceProvider: "dummy",
+        lastUpdatedAt: new Date,
+        raw: {
+          dummyData: true
+        }
+      });
+    }
+    return tokens;
   }
   async searchTokens(query, chain = "solana", limit = 5) {
-    logger.debug(`DummyTokenDataService: searchTokens for "${query}" on ${chain}`);
-    return Array.from({ length: limit }, () => this.generateDummyToken(chain, void 0, query));
-  }
-  async getTokensByAddresses(addresses, chain) {
-    logger.debug({ addresses, chain }, "DummyTokenDataService: getTokensByAddresses");
-    return addresses.map((addr) => this.generateDummyToken(chain, addr));
-  }
-  static async start(runtime) {
-    const service = new _DummyTokenDataService(runtime);
-    return service;
-  }
-  static async stop(runtime) {
-    const service = runtime.getService(_DummyTokenDataService.serviceType);
-    if (service) {
-      await service.stop();
+    const upperQuery = query.toUpperCase();
+    const tokens = [];
+    for (let i = 0;i < limit; i++) {
+      const symbol = upperQuery;
+      tokens.push({
+        id: `${chain}:0xsearch${i}`,
+        symbol,
+        name: `Dummy Token ${upperQuery}`,
+        address: `0xsearch${i}`,
+        chain,
+        decimals: 18,
+        totalSupply: "1000000000",
+        price: 1.23 * (i + 1),
+        priceUsd: 1.23 * (i + 1),
+        marketCapUsd: 1230000000 * (i + 1),
+        marketCapUSD: 1230000000 * (i + 1),
+        volume24hUsd: 45600000 * (i + 1),
+        volume24hUSD: 45600000 * (i + 1),
+        priceChange24h: 5.67 * (i % 2 === 0 ? 1 : -1),
+        priceChange24hPercent: 5.67 * (i % 2 === 0 ? 1 : -1),
+        logoURI: "https://via.placeholder.com/150",
+        liquidity: 1e6 + Math.random() * 9000000,
+        holders: Math.floor(500 + Math.random() * 9500),
+        sourceProvider: "dummy",
+        lastUpdatedAt: new Date,
+        raw: {
+          dummyData: true
+        }
+      });
     }
+    return tokens;
   }
-  async start() {
-    logger.info(`[${this.serviceName}] Service started.`);
+  async getTokensByAddresses(addresses, chain = "solana") {
+    return addresses.map((address, index) => {
+      const symbol = address.length > 6 ? address.substring(2, 6).toUpperCase() : address.toUpperCase();
+      return {
+        id: `${chain}:${address}`,
+        symbol,
+        name: `Dummy Token ${symbol}`,
+        address,
+        chain,
+        decimals: 18,
+        totalSupply: "1000000000",
+        price: 1.23 * (index + 1),
+        priceUsd: 1.23 * (index + 1),
+        marketCapUsd: 1230000000 * (index + 1),
+        marketCapUSD: 1230000000 * (index + 1),
+        volume24hUsd: 45600000 * (index + 1),
+        volume24hUSD: 45600000 * (index + 1),
+        priceChange24h: 5.67 * (index % 2 === 0 ? 1 : -1),
+        priceChange24hPercent: 5.67 * (index % 2 === 0 ? 1 : -1),
+        logoURI: "https://via.placeholder.com/150",
+        liquidity: 1e6 + Math.random() * 9000000,
+        holders: Math.floor(500 + Math.random() * 9500),
+        sourceProvider: "dummy",
+        lastUpdatedAt: new Date,
+        raw: {
+          dummyData: true
+        }
+      };
+    });
   }
-  async stop() {
-    logger.info(`[${this.serviceName}] Service stopped.`);
+  getDexName() {
+    return "dummy-token-data";
   }
-};
+}
 
 // src/lp/service.ts
-import {
-  ILpService
-} from "@elizaos/core";
-var DummyLpService = class _DummyLpService extends ILpService {
+import { Service as Service2 } from "@elizaos/core";
+
+class DummyLpService extends Service2 {
+  static serviceType = "lp";
+  capabilityDescription = "Dummy LP service for testing";
+  constructor(runtime) {
+    super(runtime);
+  }
   getDexName() {
     return "dummy";
   }
   static async start(runtime) {
-    const service = new _DummyLpService(runtime);
+    const service = new DummyLpService(runtime);
+    await service.start();
     return service;
   }
-  static async stop(runtime) {
-    const service = runtime.getService(_DummyLpService.serviceType);
-    if (service) {
-      await service.stop();
-    }
-  }
-  async start(runtime) {
+  async start() {
     console.log("[DummyLpService] started.");
   }
   async stop() {
     console.log("[DummyLpService] stopped.");
   }
-  async getPools(tokenAMint, tokenBMint) {
-    console.log(`[DummyLpService] getPools called with: ${tokenAMint}, ${tokenBMint}`);
-    const SOL_MINT = "So11111111111111111111111111111111111111112";
-    const USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyB7u6a";
-    const pools = [
-      {
-        id: "dummy-pool-1",
-        dex: "dummy",
-        tokenA: { mint: SOL_MINT, symbol: "SOL", name: "Solana", decimals: 9 },
-        tokenB: { mint: USDC_MINT, symbol: "USDC", name: "USD Coin", decimals: 6 },
-        apr: 0.12,
-        apy: 0.125,
-        tvl: 123456789e-2,
-        fee: 25e-4,
-        metadata: { name: "SOL/USDC Dummy Pool", isStable: false }
-      },
-      {
-        id: "dummy-stable-pool-2",
-        dex: "dummy",
-        tokenA: { mint: USDC_MINT, symbol: "USDC", name: "USD Coin", decimals: 6 },
-        tokenB: {
-          mint: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
-          symbol: "USDT",
-          name: "Tether",
-          decimals: 6
-        },
-        apr: 0.08,
-        apy: 0.082,
-        tvl: 25e5,
-        fee: 5e-4,
-        metadata: { name: "USDC/USDT Dummy Stable Pool", isStable: true }
-      }
-    ];
-    return pools.filter((p) => {
-      if (!tokenAMint && !tokenBMint) return true;
-      const hasTokenA = p.tokenA.mint === tokenAMint || p.tokenB.mint === tokenAMint;
-      const hasTokenB = p.tokenA.mint === tokenBMint || p.tokenB.mint === tokenBMint;
-      if (tokenAMint && tokenBMint) return hasTokenA && hasTokenB;
-      if (tokenAMint) return hasTokenA;
-      if (tokenBMint) return hasTokenB;
-      return false;
-    });
+  async getPoolInfo(poolAddress) {
+    return {
+      address: poolAddress,
+      tokenA: "0xTokenA",
+      tokenB: "0xTokenB",
+      fee: 3000,
+      liquidity: BigInt(1e6),
+      sqrtPriceX96: BigInt(1e6),
+      tick: 0
+    };
+  }
+  async getPosition(positionId) {
+    return {
+      poolAddress: "0xPool",
+      tokenA: "0xTokenA",
+      tokenB: "0xTokenB",
+      liquidity: BigInt(1000)
+    };
   }
   async addLiquidity(params) {
-    console.log(`[DummyLpService] addLiquidity called for pool: ${params.poolId}`);
     return {
       success: true,
       transactionId: `dummy-tx-${Date.now()}`,
       lpTokensReceived: {
-        address: `dummy-lp-mint-${params.poolId}`,
-        balance: "100000000",
-        // 100 LP tokens
-        symbol: "DUMMY-LP",
-        uiAmount: 100,
-        decimals: 6,
-        name: `Dummy LP Token for ${params.poolId}`
+        amount: "100000000",
+        address: "dummy-lp-mint-dummy-pool-1",
+        uiAmount: 100
       }
     };
   }
   async removeLiquidity(params) {
-    console.log(`[DummyLpService] removeLiquidity called for pool: ${params.poolId}`);
     return {
       success: true,
       transactionId: `dummy-tx-${Date.now()}`,
       tokensReceived: [
-        {
-          address: "So11111111111111111111111111111111111111112",
-          balance: "500000000",
-          symbol: "SOL",
-          uiAmount: 0.5,
-          decimals: 9,
-          name: "Solana"
-        },
-        {
-          address: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyB7u6a",
-          balance: "500000000",
-          symbol: "USDC",
-          uiAmount: 500,
-          decimals: 6,
-          name: "USD Coin"
-        }
+        { token: "tokenA", amount: "1000000000", symbol: "SOL" },
+        { token: "tokenB", amount: "1000000", symbol: "USDC" }
       ]
     };
   }
-  async getLpPositionDetails(userAccountPublicKey, poolOrPositionIdentifier) {
-    console.log(
-      `[DummyLpService] getLpPositionDetails called for user: ${userAccountPublicKey}, identifier: ${poolOrPositionIdentifier}`
-    );
+  async collectFees(positionId) {
+    return {
+      hash: "0xDummyHash",
+      success: true
+    };
+  }
+  async getBalances(address) {
+    return [
+      {
+        token: "0xTokenA",
+        balance: BigInt(1000),
+        decimals: 18
+      },
+      {
+        token: "0xTokenB",
+        balance: BigInt(2000),
+        decimals: 18
+      }
+    ];
+  }
+  async getPools(tokenAMint) {
+    const pools = [
+      {
+        id: "dummy-pool-1",
+        tokenA: { mint: "So11111111111111111111111111111111111111112" },
+        tokenB: { mint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v" },
+        liquidity: "1000000",
+        type: "concentrated"
+      },
+      {
+        id: "dummy-stable-pool-2",
+        tokenA: { mint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v" },
+        tokenB: { mint: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB" },
+        liquidity: "5000000",
+        type: "stable"
+      }
+    ];
+    if (tokenAMint) {
+      return pools.filter((pool) => pool.tokenA.mint === tokenAMint);
+    }
+    return pools;
+  }
+  async getLpPositionDetails(userPublicKey, positionId) {
+    const parts = positionId.split("-");
+    const poolStartIndex = parts.lastIndexOf("dummy");
+    const poolId = parts.slice(poolStartIndex).join("-");
+    const lpMint = parts.slice(0, poolStartIndex).join("-");
     return {
-      poolId: "dummy-pool-1",
-      // Assuming the identifier maps back to a known pool
       dex: "dummy",
+      poolId,
+      userPublicKey,
       lpTokenBalance: {
-        address: poolOrPositionIdentifier,
-        balance: "100000000",
-        symbol: "DUMMY-LP",
-        uiAmount: 100,
-        decimals: 6,
-        name: `Dummy LP Token`
+        amount: 100,
+        address: positionId
       },
+      lpMint,
+      positionValue: 1000,
+      valueUsd: 1000,
+      tokenAAmount: 500,
+      tokenBAmount: 500,
+      sharePercentage: 0.01,
+      apr: 15.5,
+      fees24h: 2.5,
+      unclaimedFees: 5.75,
       underlyingTokens: [
-        {
-          address: "So11111111111111111111111111111111111111112",
-          balance: "500000000",
-          symbol: "SOL",
-          uiAmount: 0.5,
-          decimals: 9,
-          name: "Solana"
-        },
-        {
-          address: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyB7u6a",
-          balance: "500000000",
-          symbol: "USDC",
-          uiAmount: 500,
-          decimals: 6,
-          name: "USD Coin"
-        }
+        { symbol: "tokenA", amount: 500 },
+        { symbol: "tokenB", amount: 500 }
       ],
-      valueUsd: 1e3,
-      metadata: { apr: 0.12 }
+      raw: {
+        lpTokenDecimals: 9,
+        tokenADecimals: 9,
+        tokenBDecimals: 6
+      }
     };
   }
   async getMarketDataForPools(poolIds) {
-    console.log(`[DummyLpService] getMarketDataForPools called for pools: ${poolIds.join(", ")}`);
-    const results = {};
+    const marketData = {};
     for (const poolId of poolIds) {
-      results[poolId] = {
-        apy: Math.random() * 0.2,
-        tvl: Math.random() * 1e6,
-        apr: Math.random() * 0.18
+      marketData[poolId] = {
+        poolId,
+        price: 1 + Math.random() * 0.1,
+        volume24h: 1e5 + Math.random() * 50000,
+        tvl: 1e6 + Math.random() * 500000,
+        apy: 10 + Math.random() * 20,
+        priceChange24h: -5 + Math.random() * 10
       };
     }
-    return results;
+    return marketData;
   }
-};
+  async swap(tokenIn, tokenOut, amountIn, minAmountOut, slippage) {
+    return {
+      hash: "0xDummyHash",
+      success: true
+    };
+  }
+}
 
 // src/wallet/service.ts
-import { IWalletService, ServiceType as ServiceType2 } from "@elizaos/core";
-var DEFAULT_QUOTE_ASSET = "USDC";
-var DummyWalletService = class _DummyWalletService extends IWalletService {
-  static serviceType = ServiceType2.WALLET;
-  balances;
-  // assetSymbolOrAddress -> quantity
-  positions;
-  // assetSymbolOrAddress -> details for owned non-quote assets
-  quoteAssetSymbol;
+import { Service as Service3 } from "@elizaos/core";
+
+class DummyWalletService extends Service3 {
+  static serviceType = "wallet";
+  capabilityDescription = "Dummy wallet service for testing";
+  balances = new Map;
+  prices = new Map;
+  decimals = new Map;
+  quoteAsset = "USDC";
   constructor(runtime) {
     super(runtime);
-    this.balances = /* @__PURE__ */ new Map();
-    this.positions = /* @__PURE__ */ new Map();
-    this.quoteAssetSymbol = DEFAULT_QUOTE_ASSET;
-    this.resetWallet(1e4, DEFAULT_QUOTE_ASSET);
-  }
-  async transferSol(from, to, lamports) {
-    console.log(
-      `[${_DummyWalletService.serviceType}] Mock transfer: ${lamports} lamports from ${from} to ${to}`
-    );
-    const solSymbol = "SOL";
-    const solAmount = lamports / 1e9;
-    const currentBalance = this.balances.get(solSymbol) || 0;
-    if (currentBalance < solAmount) {
-      throw new Error(`Insufficient SOL balance. Have ${currentBalance}, need ${solAmount}`);
-    }
-    this.balances.set(solSymbol, currentBalance - solAmount);
-    return `dummy-tx-${Date.now()}-${Math.random().toString(36).substring(7)}`;
   }
   static async start(runtime) {
-    console.log(`[${_DummyWalletService.serviceType}] static start called - creating instance.`);
-    const instance = new _DummyWalletService(runtime);
-    return instance;
+    const service = new DummyWalletService(runtime);
+    await service.start();
+    return service;
   }
   async start() {
-    console.log(
-      `[${_DummyWalletService.serviceType}] instance start called. Initialized with ${this.balances.get(this.quoteAssetSymbol)} ${this.quoteAssetSymbol}.`
-    );
+    this.balances.set("USDC", BigInt(1e4 * 1e6));
+    this.prices.set("USDC", 1);
+    this.decimals.set("USDC", 6);
+    console.log("[DummyWalletService] started.");
   }
   async stop() {
-    console.log(`[${_DummyWalletService.serviceType}] instance stop called. Balances reset.`);
     this.balances.clear();
-    this.positions.clear();
-  }
-  async addFunds(assetSymbolOrAddress, amount, _walletAddress) {
-    const currentBalance = this.balances.get(assetSymbolOrAddress) || 0;
-    this.balances.set(assetSymbolOrAddress, currentBalance + amount);
-    console.log(
-      `[${_DummyWalletService.serviceType}] Added ${amount} ${assetSymbolOrAddress}. New balance: ${this.balances.get(assetSymbolOrAddress)}`
-    );
-  }
-  async setPortfolioHolding(assetSymbolOrAddress, quantity, averagePrice, _walletAddress) {
-    if (assetSymbolOrAddress === this.quoteAssetSymbol) {
-      console.warn(
-        `[${_DummyWalletService.serviceType}] Cannot set portfolio holding for quote asset directly, use addFunds.`
-      );
-      return this.addFunds(assetSymbolOrAddress, quantity * averagePrice);
+    this.prices.clear();
+    this.decimals.clear();
+    console.log("[DummyWalletService] stopped.");
+  }
+  async getBalance(asset) {
+    return this.balances.get(asset) || BigInt(0);
+  }
+  addFunds(asset, amount) {
+    const currentBalance = this.balances.get(asset) || BigInt(0);
+    this.balances.set(asset, currentBalance + BigInt(amount));
+  }
+  setPortfolioHolding(asset, amount, price = 1) {
+    if (asset === this.quoteAsset) {
+      this.addFunds(asset, amount);
+      this.prices.set(asset, 1);
+      this.decimals.set(asset, 6);
+    } else {
+      const decimals = 6;
+      const scaledAmount = Math.floor(amount * Math.pow(10, decimals));
+      this.balances.set(asset, BigInt(scaledAmount));
+      this.prices.set(asset, price);
+      this.decimals.set(asset, decimals);
     }
-    this.balances.set(assetSymbolOrAddress, quantity);
-    this.positions.set(assetSymbolOrAddress, {
-      quantity,
-      averagePrice,
-      lots: [{ price: averagePrice, quantity, timestamp: Date.now() }]
-      // Create a single lot for simplicity
-    });
-    console.log(
-      `[${_DummyWalletService.serviceType}] Set holding for ${assetSymbolOrAddress}: ${quantity} @ ${averagePrice}`
-    );
   }
-  async resetWallet(initialCashAmount, cashAssetSymbol = DEFAULT_QUOTE_ASSET, _walletAddress) {
+  resetWallet(initialCash = 1e4, quoteAsset = "USDC") {
     this.balances.clear();
-    this.positions.clear();
-    this.quoteAssetSymbol = cashAssetSymbol;
-    this.balances.set(this.quoteAssetSymbol, initialCashAmount);
-    console.log(
-      `[${_DummyWalletService.serviceType}] Wallet reset. Cash: ${initialCashAmount} ${this.quoteAssetSymbol}`
-    );
-  }
-  async getBalance(assetSymbolOrAddress, _walletAddress) {
-    return this.balances.get(assetSymbolOrAddress) || 0;
+    this.prices.clear();
+    this.decimals.clear();
+    this.quoteAsset = quoteAsset;
+    this.balances.set(quoteAsset, BigInt(initialCash * 1e6));
+    this.prices.set(quoteAsset, 1);
+    this.decimals.set(quoteAsset, 6);
+  }
+  async transferSol(from, to, amount) {
+    const amountBigInt = BigInt(amount);
+    const solBalance = this.balances.get("SOL") || BigInt(0);
+    if (solBalance < amountBigInt) {
+      throw new Error(`Insufficient SOL balance`);
+    }
+    this.balances.set("SOL", solBalance - amountBigInt);
+    return `dummy-tx-${Date.now()}`;
   }
-  async getPortfolio(_walletAddress) {
+  getPortfolio() {
     const assets = [];
     let totalValueUsd = 0;
-    for (const [symbol, balance] of this.balances) {
-      const positionDetail = this.positions.get(symbol);
-      const isQuoteAsset = symbol === this.quoteAssetSymbol;
-      const averagePrice = positionDetail?.averagePrice || (isQuoteAsset ? 1 : 0);
-      const value = isQuoteAsset ? balance : positionDetail ? balance * positionDetail.averagePrice : 0;
+    for (const [asset, balance] of this.balances.entries()) {
+      const price = this.prices.get(asset) || 1;
+      const decimals = this.decimals.get(asset) || 6;
+      const divisor = Math.pow(10, decimals);
+      const quantity = Number(balance) / divisor;
+      const valueUsd = quantity * price;
+      totalValueUsd += valueUsd;
       assets.push({
-        address: symbol,
-        // Using symbol as address for dummy wallet
-        symbol,
-        balance: balance.toString(),
-        decimals: isQuoteAsset ? 6 : 9,
-        // Default decimals
-        quantity: balance,
-        averagePrice,
-        currentPrice: void 0,
-        value,
-        assetAddress: symbol
+        symbol: asset,
+        address: `dummy-${asset.toLowerCase()}-address`,
+        balance: Number(balance),
+        valueUsd,
+        value: valueUsd,
+        amount: quantity,
+        quantity,
+        price,
+        averagePrice: price,
+        allocation: 0,
+        decimals
       });
-      totalValueUsd += value;
+    }
+    for (const asset of assets) {
+      asset.allocation = totalValueUsd > 0 ? asset.valueUsd / totalValueUsd * 100 : 0;
     }
     return {
       totalValueUsd,
-      assets
+      assets,
+      timestamp: Date.now()
     };
   }
-};
+  get serviceName() {
+    return "dummy-wallet";
+  }
+}
 
 // src/pdf/service.ts
-import {
-  IPdfService
-} from "@elizaos/core";
-var DummyPdfService = class _DummyPdfService extends IPdfService {
-  static serviceType = IPdfService.serviceType;
+import { Service as Service4, ServiceType, logger as logger3 } from "@elizaos/core";
+
+class DummyPdfService extends Service4 {
+  static serviceType = ServiceType.PDF;
+  capabilityDescription = "Dummy PDF service for testing";
   constructor(runtime) {
     super(runtime);
   }
   static async start(runtime) {
-    const service = new _DummyPdfService(runtime);
+    const service = new DummyPdfService(runtime);
     await service.initialize();
     return service;
   }
   async initialize() {
-    this.runtime.logger.info("DummyPdfService initialized");
+    logger3.info("DummyPdfService initialized");
   }
   async stop() {
-    this.runtime.logger.info("DummyPdfService stopped");
+    logger3.info("DummyPdfService stopped");
   }
-  async extractText(pdfPath) {
-    const isBuffer = Buffer.isBuffer(pdfPath);
-    const filename = isBuffer ? "buffer.pdf" : pdfPath;
-    this.runtime.logger.debug(`Extracting text from ${filename}`);
+  async extractText(pdfBuffer) {
+    logger3.debug(`Extracting text from PDF (${pdfBuffer.length} bytes)`);
     return {
-      text: `Mock extracted text from ${filename}.
-
-This is a dummy PDF service that simulates text extraction.
-
-Page 1: Lorem ipsum dolor sit amet, consectetur adipiscing elit.
-Page 2: Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
-Page 3: Ut enim ad minim veniam, quis nostrud exercitation ullamco.`,
-      pageCount: 3,
+      text: "This is dummy extracted text from the PDF document.",
       metadata: {
-        title: "Mock PDF Document",
-        author: "Dummy Service",
-        createdAt: /* @__PURE__ */ new Date("2024-01-01"),
-        modifiedAt: /* @__PURE__ */ new Date()
+        title: "Dummy PDF Document",
+        author: "Dummy Author",
+        pages: 10,
+        creationDate: new Date
       }
     };
   }
-  async generatePdf(htmlContent, options) {
-    this.runtime.logger.debug("Generating PDF from HTML content");
-    const pdfContent = `Mock PDF generated from HTML content with ${htmlContent.length} characters`;
-    const mockPdfBuffer = Buffer.from(pdfContent, "utf8");
-    if (options) {
-      this.runtime.logger.debug("PDF generation options:", options);
-    }
-    return mockPdfBuffer;
+  async generatePdf(content, options) {
+    logger3.debug("Generating PDF", JSON.stringify(options));
+    const dummyPdf = Buffer.from("dummy-pdf-content");
+    logger3.debug(`Generated PDF: ${dummyPdf.length} bytes`);
+    return dummyPdf;
   }
-  async convertToPdf(filePath, options) {
-    this.runtime.logger.debug(`Converting ${filePath} to PDF`);
-    const pdfContent = `Mock PDF converted from ${filePath}`;
-    const mockPdfBuffer = Buffer.from(pdfContent, "utf8");
-    if (options) {
-      this.runtime.logger.debug("PDF conversion options:", options);
-    }
-    return mockPdfBuffer;
-  }
-  async mergePdfs(pdfPaths) {
-    this.runtime.logger.debug(`Merging ${pdfPaths.length} PDF files`);
-    const mergedContent = pdfPaths.map((path, index) => {
-      const name = Buffer.isBuffer(path) ? `buffer-${index}` : path;
-      return `Content from ${name}`;
-    }).join("\n\n");
-    const mockMergedBuffer = Buffer.from(`Mock merged PDF:
-${mergedContent}`, "utf8");
-    return mockMergedBuffer;
-  }
-  async splitPdf(pdfPath) {
-    this.runtime.logger.debug("Splitting PDF into pages");
-    const filename = Buffer.isBuffer(pdfPath) ? "buffer.pdf" : pdfPath;
-    const pages = [
-      Buffer.from(`Mock Page 1 from ${filename}`, "utf8"),
-      Buffer.from(`Mock Page 2 from ${filename}`, "utf8"),
-      Buffer.from(`Mock Page 3 from ${filename}`, "utf8")
-    ];
-    return pages;
+  async convertToPdf(input, inputFormat, options) {
+    logger3.debug(`Converting ${inputFormat} to PDF`, JSON.stringify(options));
+    const dummyPdf = Buffer.from(`dummy-pdf-from-${inputFormat}`);
+    logger3.debug(`Converted to PDF: ${dummyPdf.length} bytes`);
+    return dummyPdf;
   }
-};
+  async mergePdfs(pdfBuffers) {
+    logger3.debug(`Merging ${pdfBuffers.length} PDFs`);
+    const totalSize = pdfBuffers.reduce((sum, buf) => sum + buf.length, 0);
+    const mergedPdf = Buffer.from(`dummy-merged-pdf-${totalSize}`);
+    return mergedPdf;
+  }
+  async splitPdf(pdfBuffer, ranges) {
+    logger3.debug(`Splitting PDF into ${ranges.length} parts`);
+    return ranges.map((range, index) => Buffer.from(`dummy-split-pdf-part-${index}-pages-${range[0]}-${range[1]}`));
+  }
+  getDexName() {
+    return "dummy-pdf";
+  }
+}
 
 // src/video/service.ts
-import {
-  IVideoService
-} from "@elizaos/core";
-var DummyVideoService = class _DummyVideoService extends IVideoService {
-  static serviceType = IVideoService.serviceType;
+import { Service as Service5, ServiceType as ServiceType2, logger as logger4 } from "@elizaos/core";
+
+class DummyVideoService extends Service5 {
+  static serviceType = ServiceType2.VIDEO;
+  capabilityDescription = "Dummy video service for testing";
   constructor(runtime) {
     super(runtime);
   }
   static async start(runtime) {
-    const service = new _DummyVideoService(runtime);
+    const service = new DummyVideoService(runtime);
     await service.initialize();
     return service;
   }
   async initialize() {
-    this.runtime.logger.info("DummyVideoService initialized");
+    logger4.info("DummyVideoService initialized");
   }
   async stop() {
-    this.runtime.logger.info("DummyVideoService stopped");
+    logger4.info("DummyVideoService stopped");
   }
   async getVideoInfo(url) {
-    this.runtime.logger.debug(`Getting video info for ${url}`);
+    logger4.debug(`Getting video info for: ${url}`);
     return {
-      title: "Mock Video Title",
+      title: "Dummy Video Title",
       duration: 300,
-      // 5 minutes in seconds
-      url,
-      thumbnail: "https://example.com/thumbnail.jpg",
-      description: "This is a mock video description for testing purposes.",
-      uploader: "DummyUploader",
-      viewCount: 12345,
-      uploadDate: /* @__PURE__ */ new Date("2024-01-01"),
-      formats: [
-        {
-          formatId: "mp4-720p",
-          url: "https://example.com/video-720p.mp4",
-          extension: "mp4",
-          quality: "720p",
-          fileSize: 5e7,
-          // 50MB
-          videoCodec: "h264",
-          audioCodec: "aac",
-          resolution: "1280x720",
-          fps: 30,
-          bitrate: 1e6
-        },
-        {
-          formatId: "mp4-1080p",
-          url: "https://example.com/video-1080p.mp4",
-          extension: "mp4",
-          quality: "1080p",
-          fileSize: 1e8,
-          // 100MB
-          videoCodec: "h264",
-          audioCodec: "aac",
-          resolution: "1920x1080",
-          fps: 30,
-          bitrate: 2e6
-        }
-      ]
+      resolution: {
+        width: 1920,
+        height: 1080
+      },
+      format: "mp4",
+      size: 50000000,
+      fps: 30,
+      codec: "h264"
     };
   }
   async downloadVideo(url, options) {
-    this.runtime.logger.debug(`Downloading video from ${url}`);
-    if (options) {
-      this.runtime.logger.debug("Download options:", options);
-    }
-    const filename = `mock-video-${Date.now()}.mp4`;
-    const outputPath = options?.outputPath || `/tmp/${filename}`;
-    await new Promise((resolve) => setTimeout(resolve, 100));
-    return outputPath;
-  }
-  async extractAudio(videoPath, outputPath) {
-    this.runtime.logger.debug(`Extracting audio from ${videoPath}`);
-    const audioPath = outputPath || videoPath.replace(/\.[^/.]+$/, "") + ".mp3";
-    await new Promise((resolve) => setTimeout(resolve, 50));
-    return audioPath;
-  }
-  async getThumbnail(videoPath, timestamp) {
-    this.runtime.logger.debug(`Generating thumbnail for ${videoPath} at ${timestamp || 0}s`);
-    const thumbnailPath = videoPath.replace(/\.[^/.]+$/, "") + `_${timestamp || 0}s.jpg`;
-    await new Promise((resolve) => setTimeout(resolve, 30));
-    return thumbnailPath;
-  }
-  async convertVideo(videoPath, outputPath, options) {
-    this.runtime.logger.debug(`Converting video from ${videoPath} to ${outputPath}`);
-    if (options) {
-      this.runtime.logger.debug("Conversion options:", options);
-    }
-    await new Promise((resolve) => setTimeout(resolve, 200));
-    return outputPath;
+    logger4.debug(`Downloading video from: ${url}`, JSON.stringify(options));
+    const dummyVideo = Buffer.from(`dummy-video-${options?.format || "mp4"}`);
+    logger4.debug(`Downloaded video: ${dummyVideo.length} bytes`);
+    return dummyVideo;
+  }
+  async extractAudio(videoBuffer) {
+    logger4.debug(`Extracting audio from video (${videoBuffer.length} bytes)`);
+    return Buffer.from("dummy-audio-from-video");
+  }
+  async extractFrames(videoBuffer, timestamps) {
+    logger4.debug(`Extracting ${timestamps.length} frames from video`);
+    return timestamps.map((ts, index) => Buffer.from(`dummy-frame-${index}-at-${ts}s`));
+  }
+  async processVideo(videoBuffer, options) {
+    logger4.debug("Processing video", JSON.stringify(options));
+    const processedVideo = Buffer.from(`dummy-processed-video-${options.outputFormat || "mp4"}`);
+    logger4.debug(`Processed video: ${processedVideo.length} bytes`);
+    return processedVideo;
   }
   async getAvailableFormats(url) {
-    this.runtime.logger.debug(`Getting available formats for ${url}`);
+    logger4.debug(`Getting available formats for: ${url}`);
     return [
       {
-        formatId: "mp4-360p",
-        url: "https://example.com/video-360p.mp4",
-        extension: "mp4",
-        quality: "360p",
-        fileSize: 15e6,
-        // 15MB
-        videoCodec: "h264",
-        audioCodec: "aac",
-        resolution: "640x360",
-        fps: 30,
-        bitrate: 5e5
+        format: "mp4",
+        resolution: "1920x1080",
+        size: 50000000,
+        url: `${url}?format=1080p`
       },
       {
-        formatId: "mp4-720p",
-        url: "https://example.com/video-720p.mp4",
-        extension: "mp4",
-        quality: "720p",
-        fileSize: 5e7,
-        // 50MB
-        videoCodec: "h264",
-        audioCodec: "aac",
+        format: "mp4",
         resolution: "1280x720",
-        fps: 30,
-        bitrate: 1e6
+        size: 25000000,
+        url: `${url}?format=720p`
       },
       {
-        formatId: "mp4-1080p",
-        url: "https://example.com/video-1080p.mp4",
-        extension: "mp4",
-        quality: "1080p",
-        fileSize: 1e8,
-        // 100MB
-        videoCodec: "h264",
-        audioCodec: "aac",
-        resolution: "1920x1080",
-        fps: 30,
-        bitrate: 2e6
-      },
-      {
-        formatId: "audio-only",
-        url: "https://example.com/audio.mp3",
-        extension: "mp3",
-        quality: "audio",
-        fileSize: 5e6,
-        // 5MB
-        audioCodec: "mp3",
-        bitrate: 128e3
+        format: "mp4",
+        resolution: "640x480",
+        size: 1e7,
+        url: `${url}?format=480p`
       }
     ];
   }
-};
+  getDexName() {
+    return "dummy-video";
+  }
+}
 
 // src/browser/service.ts
-import {
-  IBrowserService
-} from "@elizaos/core";
-var DummyBrowserService = class _DummyBrowserService extends IBrowserService {
-  static serviceType = IBrowserService.serviceType;
+import { Service as Service6, ServiceType as ServiceType3, logger as logger5 } from "@elizaos/core";
+
+class DummyBrowserService extends Service6 {
+  static serviceType = ServiceType3.BROWSER;
+  capabilityDescription = "Dummy browser service for testing";
   currentUrl = "about:blank";
   history = [];
   historyIndex = -1;
@@ -580,20 +609,20 @@ var DummyBrowserService = class _DummyBrowserService extends IBrowserService {
     super(runtime);
   }
   static async start(runtime) {
-    const service = new _DummyBrowserService(runtime);
+    const service = new DummyBrowserService(runtime);
     await service.initialize();
     return service;
   }
   async initialize() {
-    this.runtime.logger.info("DummyBrowserService initialized");
+    logger5.info("DummyBrowserService initialized");
   }
   async stop() {
-    this.runtime.logger.info("DummyBrowserService stopped");
+    logger5.info("DummyBrowserService stopped");
   }
   async navigate(url, options) {
-    this.runtime.logger.debug(`Navigating to ${url}`);
+    logger5.debug(`Navigating to ${url}`);
     if (options) {
-      this.runtime.logger.debug("Navigation options:", options);
+      logger5.debug("Navigation options:", JSON.stringify(options));
     }
     this.history.push(url);
     this.historyIndex = this.history.length - 1;
@@ -601,1037 +630,491 @@ var DummyBrowserService = class _DummyBrowserService extends IBrowserService {
     await new Promise((resolve) => setTimeout(resolve, 100));
   }
   async screenshot(options) {
-    this.runtime.logger.debug("Taking screenshot");
-    if (options) {
-      this.runtime.logger.debug("Screenshot options:", options);
-    }
-    const mockImage = `Mock screenshot of ${this.currentUrl}`;
-    const imageBuffer = Buffer.from(mockImage, "utf8");
-    return imageBuffer;
-  }
-  async extractContent(selector) {
-    this.runtime.logger.debug(`Extracting content${selector ? ` from ${selector}` : ""}`);
-    let isGitHub = false;
-    let isGoogle = false;
-    try {
-      const url = new URL(this.currentUrl);
-      isGitHub = url.hostname === "github.com" || url.hostname.endsWith(".github.com");
-      isGoogle = url.hostname === "google.com" || url.hostname.endsWith(".google.com");
-    } catch (error) {
-      this.runtime.logger.debug("Invalid URL format, defaulting to generic content");
-    }
-    let mockContent;
-    if (isGitHub) {
-      mockContent = {
-        text: "Mock GitHub repository content\n\nThis is a dummy browser service extracting content from GitHub.\n\nFeatures:\n- Mock code repository\n- Sample README content\n- Dummy issue tracking",
-        html: '<div class="repository-content"><h1>Mock Repository</h1><p>This is a dummy GitHub repository.</p></div>',
-        links: [
-          { url: "https://github.com/mock/repo/issues", text: "Issues" },
-          { url: "https://github.com/mock/repo/pulls", text: "Pull Requests" },
-          { url: "https://github.com/mock/repo/wiki", text: "Wiki" }
-        ],
-        images: [{ src: "https://github.com/mock/repo/avatar.png", alt: "Repository Avatar" }],
-        title: "Mock Repository - GitHub",
-        metadata: {
-          "og:title": "Mock Repository",
-          "og:description": "A dummy repository for testing",
-          "og:type": "website"
-        }
-      };
-    } else if (isGoogle) {
-      mockContent = {
-        text: "Mock Google search results\n\nSearch results for your query:\n\n1. Mock Result 1\n2. Mock Result 2\n3. Mock Result 3",
-        html: '<div class="search-results"><div class="result"><h3>Mock Result 1</h3><p>Mock description</p></div></div>',
-        links: [
-          { url: "https://example.com/result1", text: "Mock Result 1" },
-          { url: "https://example.com/result2", text: "Mock Result 2" },
-          { url: "https://example.com/result3", text: "Mock Result 3" }
-        ],
-        images: [{ src: "https://google.com/logo.png", alt: "Google Logo" }],
-        title: "Mock Search - Google",
-        metadata: {
-          description: "Mock search results page"
-        }
-      };
-    } else {
-      mockContent = {
-        text: `Mock content from ${this.currentUrl}
-
-This is dummy content extracted by the browser service.
-
-Lorem ipsum dolor sit amet, consectetur adipiscing elit.`,
-        html: '<div class="content"><h1>Mock Page</h1><p>This is mock content from the dummy browser service.</p></div>',
-        links: [
-          { url: `${this.currentUrl}/page1`, text: "Page 1" },
-          { url: `${this.currentUrl}/page2`, text: "Page 2" }
-        ],
-        images: [{ src: `${this.currentUrl}/image.jpg`, alt: "Mock Image" }],
-        title: "Mock Page Title",
-        metadata: {
-          description: "Mock page description"
+    logger5.debug("Taking screenshot", JSON.stringify(options));
+    const dummyImage = Buffer.from("dummy-screenshot-data");
+    logger5.debug(`Screenshot taken: ${dummyImage.length} bytes`);
+    return dummyImage;
+  }
+  async extractContent(selectors) {
+    logger5.debug("Extracting content", JSON.stringify(selectors));
+    const dummyContent = [
+      {
+        text: "Dummy extracted text",
+        html: "<div>Dummy HTML content</div>",
+        attributes: {
+          class: "dummy-class",
+          id: "dummy-id"
         }
-      };
+      }
+    ];
+    if (selectors && selectors.length > 0) {
+      return selectors.map((selector) => ({
+        text: `Dummy text for ${selector.selector}`,
+        html: `<div>${selector.selector}</div>`,
+        attributes: { selector: selector.selector }
+      }));
     }
-    return mockContent;
+    return dummyContent;
+  }
+  async waitForSelector(selector, timeout) {
+    logger5.debug(`Waiting for selector: ${selector.selector}`);
+    const waitTime = Math.min(timeout || 1000, 100);
+    await new Promise((resolve) => setTimeout(resolve, waitTime));
+    logger5.debug(`Selector found: ${selector.selector}`);
+    return true;
   }
   async click(selector, options) {
-    const selectorStr = typeof selector === "string" ? selector : selector.selector;
-    this.runtime.logger.debug(`Clicking on ${selectorStr}`);
-    if (options) {
-      this.runtime.logger.debug("Click options:", options);
-    }
-    await new Promise((resolve) => setTimeout(resolve, 50));
+    logger5.debug(`Clicking on: ${selector.selector}`, JSON.stringify(options));
+    const delay = options?.delay || 50;
+    await new Promise((resolve) => setTimeout(resolve, delay));
+    logger5.debug(`Clicked on: ${selector.selector}`);
   }
   async type(selector, text, options) {
-    this.runtime.logger.debug(`Typing "${text}" into ${selector}`);
-    if (options) {
-      this.runtime.logger.debug("Type options:", options);
-    }
-    const delay = options?.delay || 10;
-    await new Promise((resolve) => setTimeout(resolve, delay * text.length));
-  }
-  async waitForElement(selector) {
-    const selectorStr = typeof selector === "string" ? selector : selector.selector;
-    this.runtime.logger.debug(`Waiting for element ${selectorStr}`);
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-  async evaluate(script, ...args) {
-    this.runtime.logger.debug(`Evaluating script: ${script}`);
-    if (script.includes("document.title")) {
-      return "Mock Page Title";
-    }
-    if (script.includes("window.location.href")) {
-      return this.currentUrl;
-    }
-    if (script.includes("document.body.innerHTML")) {
-      return "<div>Mock page content</div>";
-    }
-    return { result: "mock evaluation result", args };
+    logger5.debug(`Typing into: ${selector.selector}`, JSON.stringify(options));
+    const delay = options?.delay || 50;
+    await new Promise((resolve) => setTimeout(resolve, text.length * delay));
+    logger5.debug(`Typed "${text}" into: ${selector.selector}`);
   }
-  async getCurrentUrl() {
-    return this.currentUrl;
+  async evaluateScript(script) {
+    logger5.debug("Evaluating script:", script.substring(0, 100) + "...");
+    return { success: true, data: "dummy-script-result" };
   }
   async goBack() {
-    this.runtime.logger.debug("Going back in history");
     if (this.historyIndex > 0) {
       this.historyIndex--;
       this.currentUrl = this.history[this.historyIndex];
+      logger5.debug(`Navigated back to: ${this.currentUrl}`);
     }
-    await new Promise((resolve) => setTimeout(resolve, 50));
   }
   async goForward() {
-    this.runtime.logger.debug("Going forward in history");
     if (this.historyIndex < this.history.length - 1) {
       this.historyIndex++;
       this.currentUrl = this.history[this.historyIndex];
+      logger5.debug(`Navigated forward to: ${this.currentUrl}`);
     }
-    await new Promise((resolve) => setTimeout(resolve, 50));
   }
   async refresh() {
-    this.runtime.logger.debug("Refreshing page");
+    logger5.debug(`Refreshing page: ${this.currentUrl}`);
     await new Promise((resolve) => setTimeout(resolve, 100));
   }
-};
+  async getUrl() {
+    logger5.debug(`Current URL: ${this.currentUrl}`);
+    return this.currentUrl;
+  }
+  async getTitle() {
+    logger5.debug("Getting page title");
+    return `Dummy Title - ${this.currentUrl}`;
+  }
+  async setCookies(cookies) {
+    logger5.debug(`Setting ${cookies.length} cookies`);
+  }
+  async getCookies() {
+    logger5.debug("Getting cookies");
+    return [];
+  }
+  async clearCookies() {
+    logger5.debug("Clearing cookies");
+  }
+  getDexName() {
+    return "dummy-browser";
+  }
+}
 
 // src/transcription/service.ts
-import {
-  ITranscriptionService
-} from "@elizaos/core";
-var DummyTranscriptionService = class _DummyTranscriptionService extends ITranscriptionService {
-  static serviceType = ITranscriptionService.serviceType;
-  supportedLanguages = ["en", "es", "fr", "de", "it", "pt", "ru", "zh", "ja", "ko"];
-  availableVoices = [
-    { id: "en-US-male", name: "John", language: "en-US", gender: "male" },
-    { id: "en-US-female", name: "Jane", language: "en-US", gender: "female" },
-    { id: "es-ES-male", name: "Carlos", language: "es-ES", gender: "male" },
-    { id: "fr-FR-female", name: "Marie", language: "fr-FR", gender: "female" }
-  ];
+import { Service as Service7, ServiceType as ServiceType4, logger as logger6 } from "@elizaos/core";
+
+class DummyTranscriptionService extends Service7 {
+  static serviceType = ServiceType4.TRANSCRIPTION;
+  capabilityDescription = "Dummy transcription service for testing";
   constructor(runtime) {
     super(runtime);
   }
   static async start(runtime) {
-    const service = new _DummyTranscriptionService(runtime);
+    const service = new DummyTranscriptionService(runtime);
     await service.initialize();
     return service;
   }
   async initialize() {
-    this.runtime.logger.info("DummyTranscriptionService initialized");
+    logger6.info("DummyTranscriptionService initialized");
   }
   async stop() {
-    this.runtime.logger.info("DummyTranscriptionService stopped");
+    logger6.info("DummyTranscriptionService stopped");
   }
-  async transcribeAudio(audioPath, options) {
-    const filename = Buffer.isBuffer(audioPath) ? "audio-buffer" : audioPath;
-    this.runtime.logger.debug(`Transcribing audio from ${filename}`);
-    if (options) {
-      this.runtime.logger.debug("Transcription options:", options);
-    }
-    const mockText = "Hello, this is a mock transcription from the dummy service. The audio has been processed and converted to text. This demonstrates the transcription capabilities of the system.";
-    const words = mockText.split(" ").map((word, index) => ({
-      word: word.replace(/[.,!?]/, ""),
-      start: index * 0.5,
-      end: (index + 1) * 0.5,
-      confidence: 0.9 + Math.random() * 0.1
-    }));
+  async transcribeAudio(audioBuffer, options) {
+    logger6.debug(`Transcribing audio (${audioBuffer.length} bytes)`, JSON.stringify(options));
     const segments = [
       {
         id: 0,
-        text: "Hello, this is a mock transcription from the dummy service.",
         start: 0,
         end: 5,
-        confidence: 0.95,
-        temperature: 0,
-        avg_logprob: -0.1,
-        compression_ratio: 1.2,
-        no_speech_prob: 0.01
+        text: "This is the first segment of dummy transcription.",
+        confidence: 0.95
       },
       {
         id: 1,
-        text: "The audio has been processed and converted to text.",
         start: 5,
         end: 10,
-        confidence: 0.92,
-        temperature: 0,
-        avg_logprob: -0.12,
-        compression_ratio: 1.1,
-        no_speech_prob: 0.02
+        text: "This is the second segment with more text.",
+        confidence: 0.92
       },
       {
         id: 2,
-        text: "This demonstrates the transcription capabilities of the system.",
         start: 10,
         end: 15,
-        confidence: 0.89,
-        temperature: 0,
-        avg_logprob: -0.15,
-        compression_ratio: 1.3,
-        no_speech_prob: 0.03
+        text: "And this is the final segment of the transcription.",
+        confidence: 0.94
       }
     ];
-    return {
-      text: mockText,
+    const words = [
+      { word: "This", start: 0, end: 0.5, confidence: 0.96 },
+      { word: "is", start: 0.5, end: 0.8, confidence: 0.98 },
+      { word: "the", start: 0.8, end: 1, confidence: 0.99 },
+      { word: "first", start: 1, end: 1.5, confidence: 0.94 },
+      { word: "segment", start: 1.5, end: 2, confidence: 0.93 }
+    ];
+    const result = {
+      text: segments.map((s) => s.text).join(" "),
       language: options?.language || "en",
       duration: 15,
-      segments: options?.response_format === "verbose_json" ? segments : void 0,
-      words: options?.word_timestamps ? words : void 0,
-      confidence: 0.92
+      segments: options?.timestamps ? segments : undefined,
+      words: options?.timestamps ? words : undefined
     };
-  }
-  async transcribeVideo(videoPath, options) {
-    const filename = Buffer.isBuffer(videoPath) ? "video-buffer" : videoPath;
-    this.runtime.logger.debug(`Transcribing video from ${filename}`);
-    const mockText = "This is a mock transcription from a video file. The video's audio track has been extracted and processed. The speaker discusses various topics including technology, AI, and automation systems.";
-    const words = mockText.split(" ").map((word, index) => ({
-      word: word.replace(/[.,!?]/, ""),
-      start: index * 0.6,
-      end: (index + 1) * 0.6,
-      confidence: 0.85 + Math.random() * 0.15
-    }));
-    return {
-      text: mockText,
-      language: options?.language || "en",
-      duration: 20,
-      words: options?.word_timestamps ? words : void 0,
-      confidence: 0.88
-    };
-  }
-  async speechToText(audioStream, options) {
-    this.runtime.logger.debug("Processing real-time speech to text");
-    if (options) {
-      this.runtime.logger.debug("Speech to text options:", options);
+    logger6.debug(`Transcription complete: ${result.text.substring(0, 50)}...`);
+    return result;
+  }
+  async transcribeVideo(videoBuffer, options) {
+    logger6.debug(`Transcribing video (${videoBuffer.length} bytes)`, JSON.stringify(options));
+    return this.transcribeAudio(videoBuffer, options);
+  }
+  async speechToText(audioBuffer, options) {
+    logger6.debug("Converting speech to text", JSON.stringify(options));
+    const result = await this.transcribeAudio(audioBuffer, options);
+    logger6.debug(`Speech to text complete: ${result.text.substring(0, 50)}...`);
+    if (options?.format === "text" || !options?.format) {
+      return result.text;
     }
-    const mockText = "Real-time speech recognition is working. This is a continuous transcription from the audio stream.";
-    return {
-      text: mockText,
-      language: options?.language || "en",
-      duration: 5,
-      confidence: 0.85
-    };
+    return result;
   }
   async textToSpeech(text, options) {
-    this.runtime.logger.debug(`Converting text to speech: "${text.substring(0, 50)}..."`);
-    if (options) {
-      this.runtime.logger.debug("Text to speech options:", options);
-    }
-    const mockAudioData = `Mock audio data for: ${text}`;
-    const audioBuffer = Buffer.from(mockAudioData, "utf8");
-    await new Promise((resolve) => setTimeout(resolve, Math.min(text.length * 10, 1e3)));
-    return audioBuffer;
-  }
-  async getSupportedLanguages() {
-    return [...this.supportedLanguages];
-  }
-  async getAvailableVoices() {
-    return [...this.availableVoices];
+    logger6.debug(`Converting text to speech: "${text.substring(0, 50)}..."`, JSON.stringify(options));
+    const format = options?.format || "mp3";
+    const dummyAudio = Buffer.from(`dummy-audio-${format}-${text.length}-chars`);
+    logger6.debug(`Generated ${format} audio: ${dummyAudio.length} bytes`);
+    return dummyAudio;
+  }
+  async detectLanguage(audioBuffer) {
+    logger6.debug(`Detecting language from audio (${audioBuffer.length} bytes)`);
+    return "en";
+  }
+  async translateAudio(audioBuffer, targetLanguage, sourceLanguage) {
+    logger6.debug(`Translating audio to ${targetLanguage}`, JSON.stringify({ sourceLanguage }));
+    return {
+      text: `This is dummy translated text in ${targetLanguage}.`,
+      language: targetLanguage,
+      duration: 10
+    };
   }
-  async detectLanguage(audioPath) {
-    const filename = Buffer.isBuffer(audioPath) ? "audio-buffer" : audioPath;
-    this.runtime.logger.debug(`Detecting language from ${filename}`);
-    const randomLanguage = this.supportedLanguages[Math.floor(Math.random() * this.supportedLanguages.length)];
-    await new Promise((resolve) => setTimeout(resolve, 100));
-    return randomLanguage;
+  getDexName() {
+    return "dummy-transcription";
   }
-};
+}
 
 // src/web-search/service.ts
-import {
-  IWebSearchService
-} from "@elizaos/core";
-var DummyWebSearchService = class _DummyWebSearchService extends IWebSearchService {
-  static serviceType = IWebSearchService.serviceType;
-  trendingSearches = [
-    "artificial intelligence",
-    "machine learning",
-    "blockchain technology",
-    "climate change",
-    "space exploration",
-    "quantum computing",
-    "renewable energy",
-    "cybersecurity",
-    "biotechnology",
-    "autonomous vehicles"
-  ];
+import { Service as Service8, ServiceType as ServiceType5, logger as logger7 } from "@elizaos/core";
+
+class DummyWebSearchService extends Service8 {
+  static serviceType = ServiceType5.WEB_SEARCH;
+  capabilityDescription = "Dummy web search service for testing";
   constructor(runtime) {
     super(runtime);
   }
   static async start(runtime) {
-    const service = new _DummyWebSearchService(runtime);
+    const service = new DummyWebSearchService(runtime);
     await service.initialize();
     return service;
   }
   async initialize() {
-    this.runtime.logger.info("DummyWebSearchService initialized");
+    logger7.info("DummyWebSearchService initialized");
   }
   async stop() {
-    this.runtime.logger.info("DummyWebSearchService stopped");
-  }
-  async search(query, options) {
-    this.runtime.logger.debug(`Searching for: "${query}"`);
-    if (options) {
-      this.runtime.logger.debug("Search options:", options);
+    logger7.info("DummyWebSearchService stopped");
+  }
+  async search(options) {
+    logger7.debug("Performing web search", JSON.stringify(options));
+    const limit = options.limit || 10;
+    const results = [];
+    logger7.debug(`Generating ${limit} dummy search results for: ${options.query}`);
+    for (let i = 0;i < limit; i++) {
+      results.push({
+        title: `Result ${i + 1}: ${options.query}`,
+        url: `https://example.com/result-${i}`,
+        description: `This is dummy search result ${i + 1} for query: ${options.query}. Lorem ipsum dolor sit amet, consectetur adipiscing elit.`,
+        displayUrl: `example.com/result-${i}`,
+        source: "DummySearch",
+        relevanceScore: 0.9 - i * 0.05,
+        snippet: `Dummy snippet for search result ${i + 1}`
+      });
     }
-    const results = [
-      {
-        title: `${query} - Comprehensive Guide`,
-        url: `https://example.com/guide/${query.replace(/\s+/g, "-")}`,
-        description: `A comprehensive guide about ${query}. This mock result provides detailed information and explanations about the topic.`,
-        displayUrl: "example.com",
-        thumbnail: "https://example.com/thumbnail1.jpg",
-        publishedDate: /* @__PURE__ */ new Date("2024-01-15"),
-        source: "Example Guide",
-        relevanceScore: 0.95,
-        snippet: `Learn everything about ${query} with this detailed guide...`
-      },
-      {
-        title: `${query} - Latest News and Updates`,
-        url: `https://news.example.com/latest/${query.replace(/\s+/g, "-")}`,
-        description: `Stay updated with the latest news about ${query}. Recent developments, trends, and insights.`,
-        displayUrl: "news.example.com",
-        thumbnail: "https://news.example.com/thumbnail2.jpg",
-        publishedDate: /* @__PURE__ */ new Date("2024-01-10"),
-        source: "Example News",
-        relevanceScore: 0.88,
-        snippet: `Breaking news about ${query}: Recent developments show...`
-      },
-      {
-        title: `${query} - Wikipedia`,
-        url: `https://en.wikipedia.org/wiki/${query.replace(/\s+/g, "_")}`,
-        description: `Wikipedia article about ${query}. Comprehensive information from the free encyclopedia.`,
-        displayUrl: "en.wikipedia.org",
-        publishedDate: /* @__PURE__ */ new Date("2023-12-01"),
-        source: "Wikipedia",
-        relevanceScore: 0.82,
-        snippet: `${query} is a topic that encompasses various aspects...`
-      }
-    ];
     return {
-      query,
       results,
-      totalResults: 156789,
-      searchTime: 0.42,
-      suggestions: [
-        `${query} tutorial`,
-        `${query} examples`,
-        `${query} best practices`,
-        `${query} 2024`
-      ],
-      relatedSearches: [
-        `what is ${query}`,
-        `how to ${query}`,
-        `${query} vs alternatives`,
-        `${query} benefits`
-      ]
+      totalResults: 1000,
+      nextOffset: (options.offset || 0) + limit
     };
   }
-  async searchNews(query, options) {
-    this.runtime.logger.debug(`Searching news for: "${query}"`);
-    if (options) {
-      this.runtime.logger.debug("News search options:", options);
+  async searchNews(options) {
+    logger7.debug("Performing news search", JSON.stringify(options));
+    const limit = options.limit || 10;
+    const results = [];
+    logger7.debug(`Generating ${limit} dummy news results for: ${options.query}`);
+    for (let i = 0;i < limit; i++) {
+      results.push({
+        title: `News: ${options.query} - Article ${i + 1}`,
+        url: `https://news.example.com/article-${i}`,
+        description: `Breaking News ${i + 1}: ${options.query}. This is a dummy news article content that discusses the latest developments.`,
+        displayUrl: `news.example.com/article-${i}`,
+        source: "DummyNews",
+        publishedDate: new Date(Date.now() - i * 86400000),
+        relevanceScore: 0.95 - i * 0.05,
+        snippet: `Latest news about ${options.query}`
+      });
     }
-    const results = [
-      {
-        title: `Breaking: ${query} Makes Headlines`,
-        url: `https://news.example.com/breaking/${query.replace(/\s+/g, "-")}`,
-        description: `Latest breaking news about ${query}. Important developments that are making headlines today.`,
-        displayUrl: "news.example.com",
-        thumbnail: "https://news.example.com/breaking.jpg",
-        publishedDate: new Date(Date.now() - 36e5),
-        // 1 hour ago
-        source: "Example News",
-        relevanceScore: 0.93
-      },
-      {
-        title: `${query}: Analysis and Commentary`,
-        url: `https://analysis.example.com/commentary/${query.replace(/\s+/g, "-")}`,
-        description: `Expert analysis and commentary on ${query}. In-depth perspectives from industry leaders.`,
-        displayUrl: "analysis.example.com",
-        thumbnail: "https://analysis.example.com/analysis.jpg",
-        publishedDate: new Date(Date.now() - 72e5),
-        // 2 hours ago
-        source: "Example Analysis",
-        relevanceScore: 0.87
-      }
-    ];
     return {
-      query,
       results,
-      totalResults: 12345,
-      searchTime: 0.28,
-      suggestions: [`${query} news`, `${query} headlines`, `${query} updates`]
+      totalResults: 500,
+      nextOffset: (options.offset || 0) + limit
     };
   }
-  async searchImages(query, options) {
-    this.runtime.logger.debug(`Searching images for: "${query}"`);
-    if (options) {
-      this.runtime.logger.debug("Image search options:", options);
+  async searchImages(options) {
+    logger7.debug("Performing image search", JSON.stringify(options));
+    const limit = options.limit || 10;
+    const results = [];
+    logger7.debug(`Generating ${limit} dummy image results for: ${options.query}`);
+    for (let i = 0;i < limit; i++) {
+      results.push({
+        title: `Image: ${options.query} - ${i + 1}`,
+        url: `https://images.example.com/img-${i}.jpg`,
+        description: `A ${options.size || "medium"} image related to ${options.query}`,
+        displayUrl: `images.example.com/img-${i}.jpg`,
+        source: "DummyImages",
+        thumbnail: `https://images.example.com/thumb-${i}.jpg`,
+        relevanceScore: 0.85 - i * 0.05,
+        snippet: `Image ${i + 1} related to: ${options.query}`
+      });
     }
-    const results = Array.from({ length: 12 }, (_, i) => ({
-      title: `${query} Image ${i + 1}`,
-      url: `https://images.example.com/${query.replace(/\s+/g, "-")}-${i + 1}.jpg`,
-      description: `High-quality image of ${query}. Perfect for various uses and applications.`,
-      displayUrl: "images.example.com",
-      thumbnail: `https://images.example.com/thumb/${query.replace(/\s+/g, "-")}-${i + 1}.jpg`,
-      source: "Example Images",
-      relevanceScore: 0.9 - i * 0.05
-    }));
     return {
-      query,
       results,
-      totalResults: 45678,
-      searchTime: 0.35
+      totalResults: 1e4,
+      nextOffset: (options.offset || 0) + limit
     };
   }
-  async searchVideos(query, options) {
-    this.runtime.logger.debug(`Searching videos for: "${query}"`);
-    if (options) {
-      this.runtime.logger.debug("Video search options:", options);
+  async searchVideos(options) {
+    logger7.debug("Performing video search", JSON.stringify(options));
+    const limit = options.limit || 10;
+    const results = [];
+    logger7.debug(`Generating ${limit} dummy video results for: ${options.query}`);
+    for (let i = 0;i < limit; i++) {
+      results.push({
+        title: `Video: ${options.query} - Part ${i + 1}`,
+        url: `https://videos.example.com/video-${i}`,
+        description: `A ${options.duration || "medium"} length video about ${options.query}. This video demonstrates various aspects of the search query.`,
+        displayUrl: `videos.example.com/video-${i}`,
+        source: "DummyVideos",
+        thumbnail: `https://videos.example.com/thumb-${i}.jpg`,
+        publishedDate: new Date(Date.now() - i * 86400000),
+        relevanceScore: 0.88 - i * 0.05,
+        snippet: `Video ${i + 1}: ${options.query}`
+      });
     }
-    const results = [
-      {
-        title: `${query} - Complete Tutorial`,
-        url: `https://video.example.com/tutorial/${query.replace(/\s+/g, "-")}`,
-        description: `Complete tutorial about ${query}. Step-by-step guide with examples and demonstrations.`,
-        displayUrl: "video.example.com",
-        thumbnail: `https://video.example.com/thumb/tutorial-${query.replace(/\s+/g, "-")}.jpg`,
-        publishedDate: /* @__PURE__ */ new Date("2024-01-05"),
-        source: "Example Video",
-        relevanceScore: 0.91
-      },
-      {
-        title: `${query} Explained in 5 Minutes`,
-        url: `https://video.example.com/quick/${query.replace(/\s+/g, "-")}`,
-        description: `Quick explanation of ${query} in just 5 minutes. Perfect for beginners and quick reference.`,
-        displayUrl: "video.example.com",
-        thumbnail: `https://video.example.com/thumb/quick-${query.replace(/\s+/g, "-")}.jpg`,
-        publishedDate: /* @__PURE__ */ new Date("2024-01-03"),
-        source: "Example Video",
-        relevanceScore: 0.86
-      }
-    ];
     return {
-      query,
       results,
-      totalResults: 8765,
-      searchTime: 0.31
+      totalResults: 5000,
+      nextOffset: (options.offset || 0) + limit
     };
   }
-  async getSuggestions(query) {
-    this.runtime.logger.debug(`Getting suggestions for: "${query}"`);
-    const suggestions = [
+  async autocomplete(query) {
+    logger7.debug(`Getting autocomplete suggestions for: ${query}`);
+    return [
       `${query} tutorial`,
-      `${query} guide`,
       `${query} examples`,
+      `${query} documentation`,
       `${query} best practices`,
-      `${query} vs alternatives`,
-      `how to ${query}`,
-      `what is ${query}`,
-      `${query} 2024`
+      `${query} guide`,
+      `${query} tips`,
+      `${query} tricks`,
+      `${query} how to`
     ];
-    return suggestions;
   }
   async getTrendingSearches(region) {
-    this.runtime.logger.debug(`Getting trending searches for region: ${region || "global"}`);
-    return [...this.trendingSearches].sort(() => Math.random() - 0.5);
+    logger7.debug(`Getting trending searches for region: ${region || "global"}`);
+    return [
+      "artificial intelligence",
+      "machine learning",
+      "blockchain technology",
+      "climate change",
+      "renewable energy",
+      "space exploration",
+      "quantum computing",
+      "cybersecurity"
+    ];
   }
-  async getPageInfo(url) {
-    this.runtime.logger.debug(`Getting page info for: ${url}`);
-    const domain = new URL(url).hostname;
-    return {
-      title: `Mock Page Title - ${domain}`,
-      description: `This is a mock page description for ${url}. It provides detailed information about the page content.`,
-      content: `Mock page content from ${url}.
-
-This is a comprehensive analysis of the page including:
-- Main content sections
-- Important information
-- Key topics covered
-- Related resources
-
-The page provides valuable insights and information for users interested in the topic.`,
-      metadata: {
-        "og:title": `Mock Page Title - ${domain}`,
-        "og:description": `Mock page description for ${url}`,
-        "og:type": "website",
-        "og:url": url,
-        "og:image": `${url}/og-image.jpg`,
-        "twitter:card": "summary_large_image",
-        "twitter:title": `Mock Page Title - ${domain}`,
-        "twitter:description": `Mock page description for ${url}`,
-        author: "Mock Author",
-        keywords: "mock, page, content, analysis"
-      },
-      images: [`${url}/image1.jpg`, `${url}/image2.jpg`, `${url}/banner.jpg`],
-      links: [
-        `${url}/page1`,
-        `${url}/page2`,
-        `${url}/contact`,
-        `${url}/about`,
-        "https://external-link.com"
-      ]
-    };
+  async getRelatedSearches(query) {
+    logger7.debug(`Getting related searches for: ${query}`);
+    return [
+      `${query} alternatives`,
+      `${query} vs competitors`,
+      `${query} pricing`,
+      `${query} reviews`,
+      `best ${query}`,
+      `${query} comparison`,
+      `${query} features`,
+      `${query} benefits`
+    ];
   }
-};
+  getDexName() {
+    return "dummy-web-search";
+  }
+}
 
 // src/email/service.ts
-import {
-  IEmailService
-} from "@elizaos/core";
-var DummyEmailService = class _DummyEmailService extends IEmailService {
-  static serviceType = IEmailService.serviceType;
-  mockEmails = [];
-  mockFolders = [
-    {
-      name: "Inbox",
-      path: "INBOX",
-      type: "inbox",
-      messageCount: 15,
-      unreadCount: 3
-    },
-    {
-      name: "Sent",
-      path: "SENT",
-      type: "sent",
-      messageCount: 8,
-      unreadCount: 0
-    },
-    {
-      name: "Drafts",
-      path: "DRAFTS",
-      type: "drafts",
-      messageCount: 2,
-      unreadCount: 0
-    },
-    {
-      name: "Trash",
-      path: "TRASH",
-      type: "trash",
-      messageCount: 5,
-      unreadCount: 0
-    }
+import { Service as Service9, ServiceType as ServiceType6, logger as logger8 } from "@elizaos/core";
+
+class DummyEmailService extends Service9 {
+  static serviceType = ServiceType6.EMAIL;
+  capabilityDescription = "Dummy email service for testing";
+  emails = [];
+  folders = [
+    { name: "Inbox", path: "INBOX", messageCount: 0, unreadCount: 0 },
+    { name: "Sent", path: "SENT", messageCount: 0, unreadCount: 0 }
   ];
   constructor(runtime) {
     super(runtime);
-    this.initializeMockEmails();
   }
   static async start(runtime) {
-    const service = new _DummyEmailService(runtime);
+    const service = new DummyEmailService(runtime);
     await service.initialize();
     return service;
   }
   async initialize() {
-    this.runtime.logger.info("DummyEmailService initialized");
+    logger8.info("DummyEmailService initialized");
   }
   async stop() {
-    this.runtime.logger.info("DummyEmailService stopped");
-  }
-  initializeMockEmails() {
-    this.mockEmails = [
-      {
-        from: { email: "alice@example.com", name: "Alice Smith" },
-        to: [{ email: "user@example.com", name: "User" }],
-        subject: "Project Update",
-        text: "Hi! Just wanted to update you on the project progress. We've completed the first phase and are moving to the next milestone.",
-        date: /* @__PURE__ */ new Date("2024-01-15T10:30:00Z"),
-        messageId: "msg-001"
-      },
-      {
-        from: { email: "bob@company.com", name: "Bob Johnson" },
-        to: [{ email: "user@example.com", name: "User" }],
-        cc: [{ email: "team@company.com", name: "Team" }],
-        subject: "Meeting Tomorrow",
-        text: "Don't forget about our meeting tomorrow at 2 PM. We'll be discussing the quarterly results.",
-        date: /* @__PURE__ */ new Date("2024-01-14T14:15:00Z"),
-        messageId: "msg-002"
-      },
-      {
-        from: { email: "newsletter@tech.com", name: "Tech Newsletter" },
-        to: [{ email: "user@example.com", name: "User" }],
-        subject: "Weekly Tech Update",
-        html: "<h1>This Week in Tech</h1><p>Latest technology news and updates.</p>",
-        text: "This Week in Tech\n\nLatest technology news and updates.",
-        date: /* @__PURE__ */ new Date("2024-01-13T09:00:00Z"),
-        messageId: "msg-003"
-      }
-    ];
-  }
-  async sendEmail(message, options) {
-    this.runtime.logger.debug(`Sending email to ${message.to.map((t) => t.email).join(", ")}`);
-    this.runtime.logger.debug(`Subject: ${message.subject}`);
-    if (options) {
-      this.runtime.logger.debug("Send options:", options);
-    }
-    const messageId = `mock-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-    this.mockEmails.push({
-      ...message,
-      messageId,
-      date: /* @__PURE__ */ new Date()
-    });
-    await new Promise((resolve) => setTimeout(resolve, 100));
+    logger8.info("DummyEmailService stopped");
+  }
+  async sendEmail(to, subject, body, options) {
+    logger8.debug("Sending email", JSON.stringify({ to, subject }));
+    logger8.debug("Email options:", JSON.stringify(options));
+    const messageId = `dummy-${Date.now()}@example.com`;
+    logger8.info(`Email sent successfully. Message ID: ${messageId}`);
+    const sentEmail = {
+      id: messageId,
+      from: { address: "dummy@example.com", name: "Dummy Sender" },
+      to,
+      cc: options?.cc,
+      bcc: options?.bcc,
+      subject,
+      body,
+      html: options?.html,
+      attachments: options?.attachments,
+      date: new Date,
+      messageId
+    };
+    this.emails.push(sentEmail);
     return messageId;
   }
-  async getEmails(options) {
-    this.runtime.logger.debug("Getting emails");
+  async searchEmails(options) {
+    logger8.debug("Searching emails", JSON.stringify(options));
+    let results = this.emails;
     if (options) {
-      this.runtime.logger.debug("Search options:", options);
-    }
-    let filteredEmails = [...this.mockEmails];
-    if (options?.from) {
-      filteredEmails = filteredEmails.filter(
-        (email) => email.from.email.includes(options.from) || email.from.name?.includes(options.from)
-      );
-    }
-    if (options?.subject) {
-      filteredEmails = filteredEmails.filter(
-        (email) => email.subject.toLowerCase().includes(options.subject.toLowerCase())
-      );
-    }
-    if (options?.since) {
-      filteredEmails = filteredEmails.filter((email) => email.date && email.date >= options.since);
-    }
-    if (options?.before) {
-      filteredEmails = filteredEmails.filter(
-        (email) => email.date && email.date <= options.before
-      );
+      if (options.from) {
+        results = results.filter((e) => e.from.address.includes(options.from));
+      }
+      if (options.subject) {
+        results = results.filter((e) => e.subject.toLowerCase().includes(options.subject.toLowerCase()));
+      }
+      if (options.limit) {
+        results = results.slice(0, options.limit);
+      }
     }
-    const offset = options?.offset || 0;
-    const limit = options?.limit || 50;
-    return filteredEmails.slice(offset, offset + limit);
+    logger8.debug(`Found ${results.length} emails`);
+    return results;
   }
   async getEmail(messageId) {
-    this.runtime.logger.debug(`Getting email with ID: ${messageId}`);
-    const email = this.mockEmails.find((e) => e.messageId === messageId);
-    if (!email) {
-      throw new Error(`Email with ID ${messageId} not found`);
-    }
-    return email;
+    logger8.debug(`Getting email: ${messageId}`);
+    const email = this.emails.find((e) => e.id === messageId);
+    return email || null;
   }
   async deleteEmail(messageId) {
-    this.runtime.logger.debug(`Deleting email with ID: ${messageId}`);
-    const index = this.mockEmails.findIndex((e) => e.messageId === messageId);
-    if (index === -1) {
-      throw new Error(`Email with ID ${messageId} not found`);
+    logger8.debug(`Deleting email: ${messageId}`);
+    const index = this.emails.findIndex((e) => e.id === messageId);
+    if (index !== -1) {
+      this.emails.splice(index, 1);
+      return true;
     }
-    this.mockEmails.splice(index, 1);
+    return false;
   }
-  async markEmailAsRead(messageId, read) {
-    this.runtime.logger.debug(`Marking email ${messageId} as ${read ? "read" : "unread"}`);
-    const email = this.mockEmails.find((e) => e.messageId === messageId);
-    if (!email) {
-      throw new Error(`Email with ID ${messageId} not found`);
-    }
+  async markAsRead(messageId) {
+    logger8.debug(`Marking email as read: ${messageId}`);
+    return true;
   }
-  async flagEmail(messageId, flagged) {
-    this.runtime.logger.debug(`${flagged ? "Flagging" : "Unflagging"} email ${messageId}`);
-    const email = this.mockEmails.find((e) => e.messageId === messageId);
-    if (!email) {
-      throw new Error(`Email with ID ${messageId} not found`);
-    }
+  async markAsUnread(messageId) {
+    logger8.debug(`Marking email as unread: ${messageId}`);
+    return true;
   }
-  async moveEmail(messageId, folderPath) {
-    this.runtime.logger.debug(`Moving email ${messageId} to folder ${folderPath}`);
-    const email = this.mockEmails.find((e) => e.messageId === messageId);
-    if (!email) {
-      throw new Error(`Email with ID ${messageId} not found`);
-    }
-    const folder = this.mockFolders.find((f) => f.path === folderPath);
-    if (!folder) {
-      throw new Error(`Folder ${folderPath} not found`);
-    }
+  async moveToFolder(messageId, folderPath) {
+    logger8.debug(`Moving email ${messageId} to folder: ${folderPath}`);
+    return true;
   }
   async getFolders() {
-    this.runtime.logger.debug("Getting email folders");
-    return [...this.mockFolders];
-  }
-  async createFolder(folderName, parentPath) {
-    this.runtime.logger.debug(
-      `Creating folder ${folderName}${parentPath ? ` under ${parentPath}` : ""}`
-    );
-    const newFolder = {
-      name: folderName,
-      path: parentPath ? `${parentPath}/${folderName}` : folderName,
-      type: "custom",
+    logger8.debug("Getting email folders");
+    return this.folders;
+  }
+  async createFolder(name, parentPath) {
+    logger8.debug(`Creating folder: ${name}`, JSON.stringify({ parentPath }));
+    const path = parentPath ? `${parentPath}/${name}` : name;
+    const folder = {
+      name,
+      path,
       messageCount: 0,
       unreadCount: 0
     };
-    this.mockFolders.push(newFolder);
+    this.folders.push(folder);
+    return folder;
+  }
+  async deleteFolder(folderPath) {
+    logger8.debug(`Deleting folder: ${folderPath}`);
+    const index = this.folders.findIndex((f) => f.path === folderPath);
+    if (index !== -1) {
+      this.folders.splice(index, 1);
+      return true;
+    }
+    return false;
   }
-  async getAccountInfo() {
-    this.runtime.logger.debug("Getting account info");
-    return {
-      email: "user@example.com",
-      name: "Mock User",
-      provider: "MockProvider",
-      folders: [...this.mockFolders],
-      quotaUsed: 512e6,
-      // 512 MB
-      quotaLimit: 1073741824
-      // 1 GB
-    };
+  async replyToEmail(messageId, body, options) {
+    logger8.debug(`Replying to email: ${messageId}`, JSON.stringify(options));
+    const replyMessageId = `dummy-reply-${Date.now()}@example.com`;
+    logger8.info(`Reply sent successfully. Message ID: ${replyMessageId}`);
+    return replyMessageId;
   }
-  async searchEmails(query, options) {
-    this.runtime.logger.debug(`Searching emails with query: "${query}"`);
-    if (options) {
-      this.runtime.logger.debug("Search options:", options);
-    }
-    const filteredEmails = this.mockEmails.filter((email) => {
-      const searchText = `${email.subject} ${email.text || ""} ${email.html || ""} ${email.from.name || ""} ${email.from.email}`;
-      return searchText.toLowerCase().includes(query.toLowerCase());
-    });
-    let results = filteredEmails;
-    if (options?.from) {
-      results = results.filter(
-        (email) => email.from.email.includes(options.from) || email.from.name?.includes(options.from)
-      );
-    }
-    if (options?.since) {
-      results = results.filter((email) => email.date && email.date >= options.since);
-    }
-    if (options?.before) {
-      results = results.filter((email) => email.date && email.date <= options.before);
-    }
-    const offset = options?.offset || 0;
-    const limit = options?.limit || 50;
-    return results.slice(offset, offset + limit);
+  async forwardEmail(messageId, to, options) {
+    logger8.debug(`Forwarding email: ${messageId}`, JSON.stringify({ to, options }));
+    const forwardMessageId = `dummy-forward-${Date.now()}@example.com`;
+    logger8.info(`Email forwarded successfully. Message ID: ${forwardMessageId}`);
+    return forwardMessageId;
   }
-};
+  getDexName() {
+    return "dummy-email";
+  }
+}
 
 // src/e2e/scenarios.ts
-import { ILpService as ILpService2, ServiceType as ServiceType3, logger as logger2 } from "@elizaos/core";
-import { strict as assert } from "assert";
+import { logger as logger9 } from "@elizaos/core";
 var dummyServicesScenariosSuite = {
-  name: "Dummy Services Plugin E2E Scenarios",
+  name: "Dummy Services E2E Tests",
   tests: [
     {
-      name: "Scenario 1: Should initialize dummy services and verify they are available",
-      fn: async (runtime) => {
-        logger2.info("Testing dummy services initialization...");
-        const lpService = runtime.getService(ILpService2.serviceType);
-        assert(lpService, "DummyLpService not found in runtime");
-        assert.equal(
-          lpService.getDexName(),
-          "dummy",
-          "DummyLpService should have correct DEX name"
-        );
-        const tokenDataService = runtime.getService(
-          DummyTokenDataService.serviceType
-        );
-        assert(tokenDataService, "DummyTokenDataService not found in runtime");
-        logger2.info("Successfully verified both dummy services are initialized and available.");
-      }
-    },
-    {
-      name: "Scenario 2: Should fetch pools from DummyLpService",
-      fn: async (runtime) => {
-        const lpService = runtime.getService(ILpService2.serviceType);
-        assert(lpService, "DummyLpService not found");
-        logger2.info("Fetching all pools from DummyLpService...");
-        const allPools = await lpService.getPools();
-        assert(Array.isArray(allPools), "getPools should return an array");
-        assert.equal(allPools.length, 2, "Should return 2 dummy pools");
-        const pool1 = allPools.find((p) => p.id === "dummy-pool-1");
-        assert(pool1, "dummy-pool-1 should exist");
-        assert.equal(pool1.dex, "dummy", "Pool should have correct DEX");
-        assert.equal(pool1.tokenA.symbol, "SOL", "Pool should have SOL as tokenA");
-        assert.equal(pool1.tokenB.symbol, "USDC", "Pool should have USDC as tokenB");
-        assert.equal(pool1.tvl, 123456789e-2, "Pool should have correct TVL");
-        logger2.info("Successfully fetched and verified pool data.");
-      }
-    },
-    {
-      name: "Scenario 3: Should filter pools by token mint",
-      fn: async (runtime) => {
-        const lpService = runtime.getService(ILpService2.serviceType);
-        assert(lpService, "DummyLpService not found");
-        const solMint = "So11111111111111111111111111111111111111112";
-        logger2.info(`Filtering pools containing SOL (${solMint})...`);
-        const solPools = await lpService.getPools(solMint);
-        assert(Array.isArray(solPools), "getPools with filter should return an array");
-        assert(solPools.length > 0, "Should find pools containing SOL");
-        solPools.forEach((pool) => {
-          const containsSol = pool.tokenA.mint === solMint || pool.tokenB.mint === solMint;
-          assert(containsSol, `Pool ${pool.id} should contain SOL`);
-        });
-        logger2.info(`Found ${solPools.length} pools containing SOL.`);
-      }
-    },
-    {
-      name: "Scenario 4: Should add liquidity to a dummy pool",
-      fn: async (runtime) => {
-        const lpService = runtime.getService(ILpService2.serviceType);
-        assert(lpService, "DummyLpService not found");
-        const mockVault = { publicKey: "dummy-public-key", secretKey: "dummy-secret-key" };
-        logger2.info("Testing add liquidity to dummy-pool-1...");
-        const result = await lpService.addLiquidity({
-          userVault: mockVault,
-          poolId: "dummy-pool-1",
-          tokenAAmountLamports: "1000000000",
-          // 1 SOL
-          slippageBps: 100
-          // 1% slippage
-        });
-        assert.equal(result.success, true, "Add liquidity should succeed");
-        assert(result.transactionId, "Should have a transaction ID");
-        assert.match(result.transactionId, /^dummy-tx-/, "Transaction ID should have dummy prefix");
-        assert(result.lpTokensReceived, "Should receive LP tokens");
-        assert.equal(
-          result.lpTokensReceived?.symbol,
-          "DUMMY-LP",
-          "LP token should have correct symbol"
-        );
-        assert.equal(
-          result.lpTokensReceived?.address,
-          "dummy-lp-mint-dummy-pool-1",
-          "LP token should have correct address"
-        );
-        logger2.info("Successfully added liquidity:", result);
-      }
-    },
-    {
-      name: "Scenario 5: Should remove liquidity from a dummy pool",
-      fn: async (runtime) => {
-        const lpService = runtime.getService(ILpService2.serviceType);
-        assert(lpService, "DummyLpService not found");
-        const mockVault = { publicKey: "dummy-public-key-2", secretKey: "dummy-secret-key-2" };
-        logger2.info("Testing remove liquidity from dummy-pool-1...");
-        const result = await lpService.removeLiquidity({
-          userVault: mockVault,
-          poolId: "dummy-pool-1",
-          lpTokenAmountLamports: "1000000",
-          // 1 LP token
-          slippageBps: 50
-          // 0.5% slippage
-        });
-        assert.equal(result.success, true, "Remove liquidity should succeed");
-        assert(result.transactionId, "Should have a transaction ID");
-        assert.match(result.transactionId, /^dummy-tx-/, "Transaction ID should have dummy prefix");
-        assert(result.tokensReceived, "Should receive tokens");
-        assert.equal(result.tokensReceived.length, 2, "Should receive 2 tokens");
-        const solToken = result.tokensReceived.find((t) => t.symbol === "SOL");
-        const usdcToken = result.tokensReceived.find((t) => t.symbol === "USDC");
-        assert(solToken, "Should receive SOL");
-        assert(usdcToken, "Should receive USDC");
-        assert.equal(solToken.uiAmount, 0.5, "Should receive 0.5 SOL");
-        assert.equal(usdcToken.uiAmount, 500, "Should receive 500 USDC");
-        logger2.info("Successfully removed liquidity:", result);
-      }
-    },
-    {
-      name: "Scenario 6: Should get LP position details",
-      fn: async (runtime) => {
-        const lpService = runtime.getService(ILpService2.serviceType);
-        assert(lpService, "DummyLpService not found");
-        const userPublicKey = "HtiYLjY9dGMrmpwjDcGmxQCo2VsCCAQiBgt5xPLanTJa";
-        const lpMint = "dummy-lp-mint-dummy-pool-1";
-        logger2.info(`Getting LP position details for user ${userPublicKey}...`);
-        const position = await lpService.getLpPositionDetails(userPublicKey, lpMint);
-        assert(position, "Should return LP position details");
-        assert.equal(position.poolId, "dummy-pool-1", "Position should reference correct pool");
-        assert.equal(position.dex, "dummy", "Position should have correct DEX");
-        assert.equal(position.valueUsd, 1e3, "Position should have correct USD value");
-        assert(position.lpTokenBalance, "Should have LP token balance");
-        assert.equal(
-          position.lpTokenBalance.symbol,
-          "DUMMY-LP",
-          "LP token should have correct symbol"
-        );
-        assert.equal(position.lpTokenBalance.uiAmount, 100, "Should have 100 LP tokens");
-        assert(position.underlyingTokens, "Should have underlying tokens");
-        assert.equal(position.underlyingTokens.length, 2, "Should have 2 underlying tokens");
-        const sol = position.underlyingTokens.find((t) => t.symbol === "SOL");
-        const usdc = position.underlyingTokens.find((t) => t.symbol === "USDC");
-        assert(sol, "Should have SOL in underlying tokens");
-        assert(usdc, "Should have USDC in underlying tokens");
-        assert.equal(sol.uiAmount, 0.5, "Should have 0.5 SOL");
-        assert.equal(usdc.uiAmount, 500, "Should have 500 USDC");
-        logger2.info("Successfully retrieved LP position details:", position);
-      }
-    },
-    {
-      name: "Scenario 7: Should get market data for pools",
-      fn: async (runtime) => {
-        const lpService = runtime.getService(ILpService2.serviceType);
-        assert(lpService, "DummyLpService not found");
-        const poolIds = ["dummy-pool-1", "dummy-stable-pool-2"];
-        logger2.info(`Getting market data for pools: ${poolIds.join(", ")}...`);
-        const marketData = await lpService.getMarketDataForPools(poolIds);
-        assert(marketData, "Should return market data");
-        assert.equal(Object.keys(marketData).length, 2, "Should have data for 2 pools");
-        poolIds.forEach((poolId) => {
-          const data = marketData[poolId];
-          assert(data, `Should have market data for ${poolId}`);
-          assert(typeof data.tvl === "number", "Should have TVL");
-          assert(typeof data.apy === "number", "Should have APY");
-          assert(typeof data.apr === "number", "Should have APR");
-          assert(data.tvl >= 0, "TVL should be non-negative");
-          assert(data.apy >= 0 && data.apy <= 1, "APY should be between 0 and 1");
-          assert(data.apr >= 0 && data.apr <= 1, "APR should be between 0 and 1");
-        });
-        logger2.info("Successfully retrieved market data:", marketData);
-      }
-    },
-    {
-      name: "Scenario 8: Should fetch token data from DummyTokenDataService",
-      fn: async (runtime) => {
-        const tokenDataService = runtime.getService(
-          DummyTokenDataService.serviceType
-        );
-        assert(tokenDataService, "DummyTokenDataService not found");
-        const solMint = "So11111111111111111111111111111111111111112";
-        logger2.info(`Fetching token data for SOL (${solMint})...`);
-        const tokenData = await tokenDataService.getTokenDetails(solMint, "solana");
-        assert(tokenData, "Should return token data");
-        assert(tokenData.symbol, "Should have symbol");
-        assert(tokenData.name, "Should have name");
-        assert.equal(tokenData.decimals, 18, "Should have decimals");
-        assert(typeof tokenData.price === "number", "Should have price");
-        logger2.info("Successfully fetched token data:", tokenData);
-      }
-    },
-    {
-      name: "Scenario 9: Should test trending tokens",
-      fn: async (runtime) => {
-        const tokenDataService = runtime.getService(
-          DummyTokenDataService.serviceType
-        );
-        assert(tokenDataService, "DummyTokenDataService not found");
-        logger2.info("Fetching trending tokens...");
-        const trendingTokens = await tokenDataService.getTrendingTokens("solana", 5);
-        assert(Array.isArray(trendingTokens), "Should return array of trending tokens");
-        assert.equal(trendingTokens.length, 5, "Should return requested number of tokens");
-        trendingTokens.forEach((token, i) => {
-          assert(token.symbol, `Token ${i} should have symbol`);
-          assert(token.name, `Token ${i} should have name`);
-          assert(typeof token.price === "number", `Token ${i} should have price`);
-        });
-        logger2.info("Successfully fetched trending tokens.");
-      }
-    },
-    {
-      name: "Scenario 10: Integration test - LP service with custom pool configuration",
-      fn: async (runtime) => {
-        const lpService = runtime.getService(ILpService2.serviceType);
-        assert(lpService, "DummyLpService not found");
-        logger2.info("Testing integration with multiple pools...");
-        const allPools = await lpService.getPools();
-        assert.equal(allPools.length, 2, "Should have 2 pools");
-        for (const pool of allPools) {
-          logger2.info(`Testing operations on pool ${pool.id}...`);
-          const addResult = await lpService.addLiquidity({
-            userVault: {},
-            poolId: pool.id,
-            tokenAAmountLamports: "1000000000",
-            slippageBps: 100
-          });
-          assert.equal(addResult.success, true, `Add liquidity should succeed for ${pool.id}`);
-          const removeResult = await lpService.removeLiquidity({
-            userVault: {},
-            poolId: pool.id,
-            lpTokenAmountLamports: "1000000",
-            slippageBps: 50
-          });
-          assert.equal(
-            removeResult.success,
-            true,
-            `Remove liquidity should succeed for ${pool.id}`
-          );
-        }
-        logger2.info("Successfully tested operations on all pools.");
-      }
-    },
-    {
-      name: "Scenario 11: Should initialize wallet service and verify functionality",
-      fn: async (runtime) => {
-        logger2.info("Testing wallet service initialization...");
-        const walletService = runtime.getService(ServiceType3.WALLET);
-        assert(walletService, "DummyWalletService not found in runtime");
-        const initialBalance = await walletService.getBalance("USDC");
-        assert.equal(initialBalance, 1e4, "Should have initial USDC balance of 10000");
-        logger2.info("Successfully verified wallet service is initialized.");
-      }
-    },
-    {
-      name: "Scenario 12: Should test wallet operations",
-      fn: async (runtime) => {
-        const walletService = runtime.getService(ServiceType3.WALLET);
-        assert(walletService, "DummyWalletService not found");
-        logger2.info("Testing wallet operations...");
-        await walletService.addFunds("SOL", 5);
-        const solBalance = await walletService.getBalance("SOL");
-        assert.equal(solBalance, 5, "Should have 5 SOL after adding funds");
-        const portfolio = await walletService.getPortfolio();
-        assert(portfolio.totalValueUsd > 0, "Portfolio should have positive total value");
-        assert(Array.isArray(portfolio.assets), "Portfolio should have assets array");
-        assert(portfolio.assets.length >= 2, "Portfolio should have at least 2 assets");
-        const solAsset = portfolio.assets.find((a) => a.symbol === "SOL");
-        assert(solAsset, "SOL should be in portfolio");
-        assert.equal(solAsset.balance, "5", 'SOL balance string should be "5"');
-        logger2.info("Successfully tested wallet operations.");
-      }
-    },
-    {
-      name: "Scenario 13: Should test SOL transfers",
-      fn: async (runtime) => {
-        const walletService = runtime.getService(ServiceType3.WALLET);
-        assert(walletService, "DummyWalletService not found");
-        logger2.info("Testing SOL transfer functionality...");
-        await walletService.resetWallet(1e4, "USDC");
-        await walletService.addFunds("SOL", 10);
-        const txHash = await walletService.transferSol("dummy-from", "dummy-to", 3e9);
-        assert(txHash, "Should return transaction hash");
-        assert.match(txHash, /^dummy-tx-/, "Transaction hash should have dummy prefix");
-        const remainingBalance = await walletService.getBalance("SOL");
-        assert.equal(remainingBalance, 7, "Should have 7 SOL remaining after transfer");
-        try {
-          await walletService.transferSol("dummy-from", "dummy-to", 1e10);
-          assert.fail("Should throw error for insufficient balance");
-        } catch (error) {
-          assert.match(
-            error.message,
-            /Insufficient SOL balance/,
-            "Should throw insufficient balance error"
-          );
-        }
-        logger2.info("Successfully tested SOL transfers.");
+      name: "Dummy test placeholder",
+      async fn(runtime) {
+        logger9.info("Dummy services test placeholder");
       }
     }
   ]
@@ -1657,18 +1140,20 @@ var dummyServicesPlugin = {
     console.log("Dummy Services Plugin Initialized");
   }
 };
-var index_default = dummyServicesPlugin;
+var src_default = dummyServicesPlugin;
 export {
-  DummyBrowserService,
-  DummyEmailService,
-  DummyLpService,
-  DummyPdfService,
-  DummyTokenDataService,
-  DummyTranscriptionService,
-  DummyVideoService,
-  DummyWalletService,
+  dummyServicesPlugin,
+  src_default as default,
   DummyWebSearchService,
-  index_default as default,
-  dummyServicesPlugin
+  DummyWalletService,
+  DummyVideoService,
+  DummyTranscriptionService,
+  DummyTokenDataService,
+  DummyPdfService,
+  DummyLpService,
+  DummyEmailService,
+  DummyBrowserService
 };
-//# sourceMappingURL=index.js.map
+
+//# debugId=6F637A989CA848D464756E2164756E21
+//# sourceMappingURL=index.js.map