@elizaos/plugin-dummy-services 1.2.5 → 1.2.8

package/dist/index.js

@@ -1,14 +1,9 @@
 // src/tokenData/service.ts
-import {
-  Service,
-  ServiceType,
-  logger
-} from "@elizaos/core";
+import { ITokenDataService, ServiceType, logger } from "@elizaos/core";
 import { v4 as uuidv4 } from "uuid";
-var DummyTokenDataService = class _DummyTokenDataService extends Service {
+var DummyTokenDataService = class _DummyTokenDataService extends ITokenDataService {
   serviceName = "dummy-token-data";
   static serviceType = ServiceType.TOKEN_DATA;
-  capabilityDescription = "Provides dummy token data for testing and development purposes.";
   constructor(runtime) {
     super(runtime);
     logger.info("DummyTokenDataService initialized");
@@ -232,11 +227,10 @@ var DummyLpService = class _DummyLpService extends ILpService {
 };
 
 // src/wallet/service.ts
-import { Service as Service3, ServiceType as ServiceType2 } from "@elizaos/core";
+import { IWalletService, ServiceType as ServiceType2 } from "@elizaos/core";
 var DEFAULT_QUOTE_ASSET = "USDC";
-var DummyWalletService = class _DummyWalletService extends Service3 {
+var DummyWalletService = class _DummyWalletService extends IWalletService {
   static serviceType = ServiceType2.WALLET;
-  capabilityDescription = "Provides standardized access to wallet balances and portfolios.";
   balances;
   // assetSymbolOrAddress -> quantity
   positions;
@@ -344,6 +338,1003 @@ var DummyWalletService = class _DummyWalletService extends Service3 {
   }
 };
 
+// src/pdf/service.ts
+import {
+  IPdfService
+} from "@elizaos/core";
+var DummyPdfService = class _DummyPdfService extends IPdfService {
+  static serviceType = IPdfService.serviceType;
+  constructor(runtime) {
+    super(runtime);
+  }
+  static async start(runtime) {
+    const service = new _DummyPdfService(runtime);
+    await service.initialize();
+    return service;
+  }
+  async initialize() {
+    this.runtime.logger.info("DummyPdfService initialized");
+  }
+  async stop() {
+    this.runtime.logger.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}`);
+    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,
+      metadata: {
+        title: "Mock PDF Document",
+        author: "Dummy Service",
+        createdAt: /* @__PURE__ */ new Date("2024-01-01"),
+        modifiedAt: /* @__PURE__ */ 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 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;
+  }
+};
+
+// src/video/service.ts
+import {
+  IVideoService
+} from "@elizaos/core";
+var DummyVideoService = class _DummyVideoService extends IVideoService {
+  static serviceType = IVideoService.serviceType;
+  constructor(runtime) {
+    super(runtime);
+  }
+  static async start(runtime) {
+    const service = new _DummyVideoService(runtime);
+    await service.initialize();
+    return service;
+  }
+  async initialize() {
+    this.runtime.logger.info("DummyVideoService initialized");
+  }
+  async stop() {
+    this.runtime.logger.info("DummyVideoService stopped");
+  }
+  async getVideoInfo(url) {
+    this.runtime.logger.debug(`Getting video info for ${url}`);
+    return {
+      title: "Mock 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
+        }
+      ]
+    };
+  }
+  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;
+  }
+  async getAvailableFormats(url) {
+    this.runtime.logger.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
+      },
+      {
+        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
+      },
+      {
+        formatId: "audio-only",
+        url: "https://example.com/audio.mp3",
+        extension: "mp3",
+        quality: "audio",
+        fileSize: 5e6,
+        // 5MB
+        audioCodec: "mp3",
+        bitrate: 128e3
+      }
+    ];
+  }
+};
+
+// src/browser/service.ts
+import {
+  IBrowserService
+} from "@elizaos/core";
+var DummyBrowserService = class _DummyBrowserService extends IBrowserService {
+  static serviceType = IBrowserService.serviceType;
+  currentUrl = "about:blank";
+  history = [];
+  historyIndex = -1;
+  constructor(runtime) {
+    super(runtime);
+  }
+  static async start(runtime) {
+    const service = new _DummyBrowserService(runtime);
+    await service.initialize();
+    return service;
+  }
+  async initialize() {
+    this.runtime.logger.info("DummyBrowserService initialized");
+  }
+  async stop() {
+    this.runtime.logger.info("DummyBrowserService stopped");
+  }
+  async navigate(url, options) {
+    this.runtime.logger.debug(`Navigating to ${url}`);
+    if (options) {
+      this.runtime.logger.debug("Navigation options:", options);
+    }
+    this.history.push(url);
+    this.historyIndex = this.history.length - 1;
+    this.currentUrl = url;
+    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"
+        }
+      };
+    }
+    return mockContent;
+  }
+  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));
+  }
+  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 };
+  }
+  async getCurrentUrl() {
+    return this.currentUrl;
+  }
+  async goBack() {
+    this.runtime.logger.debug("Going back in history");
+    if (this.historyIndex > 0) {
+      this.historyIndex--;
+      this.currentUrl = this.history[this.historyIndex];
+    }
+    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];
+    }
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+  async refresh() {
+    this.runtime.logger.debug("Refreshing page");
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+};
+
+// 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" }
+  ];
+  constructor(runtime) {
+    super(runtime);
+  }
+  static async start(runtime) {
+    const service = new _DummyTranscriptionService(runtime);
+    await service.initialize();
+    return service;
+  }
+  async initialize() {
+    this.runtime.logger.info("DummyTranscriptionService initialized");
+  }
+  async stop() {
+    this.runtime.logger.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
+    }));
+    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
+      },
+      {
+        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
+      },
+      {
+        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
+      }
+    ];
+    return {
+      text: mockText,
+      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
+    };
+  }
+  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);
+    }
+    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
+    };
+  }
+  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];
+  }
+  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;
+  }
+};
+
+// 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"
+  ];
+  constructor(runtime) {
+    super(runtime);
+  }
+  static async start(runtime) {
+    const service = new _DummyWebSearchService(runtime);
+    await service.initialize();
+    return service;
+  }
+  async initialize() {
+    this.runtime.logger.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);
+    }
+    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`
+      ]
+    };
+  }
+  async searchNews(query, options) {
+    this.runtime.logger.debug(`Searching news for: "${query}"`);
+    if (options) {
+      this.runtime.logger.debug("News search options:", options);
+    }
+    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`]
+    };
+  }
+  async searchImages(query, options) {
+    this.runtime.logger.debug(`Searching images for: "${query}"`);
+    if (options) {
+      this.runtime.logger.debug("Image search options:", options);
+    }
+    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
+    };
+  }
+  async searchVideos(query, options) {
+    this.runtime.logger.debug(`Searching videos for: "${query}"`);
+    if (options) {
+      this.runtime.logger.debug("Video search options:", options);
+    }
+    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
+    };
+  }
+  async getSuggestions(query) {
+    this.runtime.logger.debug(`Getting suggestions for: "${query}"`);
+    const suggestions = [
+      `${query} tutorial`,
+      `${query} guide`,
+      `${query} examples`,
+      `${query} best practices`,
+      `${query} vs alternatives`,
+      `how to ${query}`,
+      `what is ${query}`,
+      `${query} 2024`
+    ];
+    return suggestions;
+  }
+  async getTrendingSearches(region) {
+    this.runtime.logger.debug(`Getting trending searches for region: ${region || "global"}`);
+    return [...this.trendingSearches].sort(() => Math.random() - 0.5);
+  }
+  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"
+      ]
+    };
+  }
+};
+
+// 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
+    }
+  ];
+  constructor(runtime) {
+    super(runtime);
+    this.initializeMockEmails();
+  }
+  static async start(runtime) {
+    const service = new _DummyEmailService(runtime);
+    await service.initialize();
+    return service;
+  }
+  async initialize() {
+    this.runtime.logger.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));
+    return messageId;
+  }
+  async getEmails(options) {
+    this.runtime.logger.debug("Getting 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
+      );
+    }
+    const offset = options?.offset || 0;
+    const limit = options?.limit || 50;
+    return filteredEmails.slice(offset, offset + limit);
+  }
+  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;
+  }
+  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`);
+    }
+    this.mockEmails.splice(index, 1);
+  }
+  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 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 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 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",
+      messageCount: 0,
+      unreadCount: 0
+    };
+    this.mockFolders.push(newFolder);
+  }
+  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 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);
+  }
+};
+
 // src/e2e/scenarios.ts
 import { ILpService as ILpService2, ServiceType as ServiceType3 } from "@elizaos/core";
 import { strict as assert } from "assert";
@@ -650,7 +1641,17 @@ var dummyServicesScenariosSuite = {
 var dummyServicesPlugin = {
   name: "dummy-services",
   description: "Load standard dummy services for testing purposes.",
-  services: [DummyTokenDataService, DummyLpService, DummyWalletService],
+  services: [
+    DummyTokenDataService,
+    DummyLpService,
+    DummyWalletService,
+    DummyPdfService,
+    DummyVideoService,
+    DummyBrowserService,
+    DummyTranscriptionService,
+    DummyWebSearchService,
+    DummyEmailService
+  ],
   tests: [dummyServicesScenariosSuite],
   init: async (runtime) => {
     console.log("Dummy Services Plugin Initialized");
@@ -658,9 +1659,15 @@ var dummyServicesPlugin = {
 };
 var index_default = dummyServicesPlugin;
 export {
+  DummyBrowserService,
+  DummyEmailService,
   DummyLpService,
+  DummyPdfService,
   DummyTokenDataService,
+  DummyTranscriptionService,
+  DummyVideoService,
   DummyWalletService,
+  DummyWebSearchService,
   index_default as default,
   dummyServicesPlugin
 };