@elizaos/plugin-dummy-services 1.6.5 → 1.7.0-beta.0

package/dist/index.js

@@ -16,10 +16,10 @@ class DummyTokenDataService extends Service {
     return service;
   }
   async start() {
-    logger.info(`[${this.serviceName}] Service started.`);
+    logger.info({ src: "plugin:dummy-services:token-data", serviceName: this.serviceName }, `[${this.serviceName}] Service started.`);
   }
   async stop() {
-    logger.info(`[${this.serviceName}] Service stopped.`);
+    logger.info({ src: "plugin:dummy-services:token-data", serviceName: this.serviceName }, `[${this.serviceName}] Service stopped.`);
   }
   async getTokenData(tokenAddress) {
     return {
@@ -222,7 +222,7 @@ class DummyLpService extends Service2 {
       tick: 0
     };
   }
-  async getPosition(positionId) {
+  async getPosition(_positionId) {
     return {
       poolAddress: "0xPool",
       tokenA: "0xTokenA",
@@ -230,7 +230,7 @@ class DummyLpService extends Service2 {
       liquidity: BigInt(1000)
     };
   }
-  async addLiquidity(params) {
+  async addLiquidity(_params) {
     return {
       success: true,
       transactionId: `dummy-tx-${Date.now()}`,
@@ -241,7 +241,7 @@ class DummyLpService extends Service2 {
       }
     };
   }
-  async removeLiquidity(params) {
+  async removeLiquidity(_params) {
     return {
       success: true,
       transactionId: `dummy-tx-${Date.now()}`,
@@ -251,13 +251,13 @@ class DummyLpService extends Service2 {
       ]
     };
   }
-  async collectFees(positionId) {
+  async collectFees(_positionId) {
     return {
       hash: "0xDummyHash",
       success: true
     };
   }
-  async getBalances(address) {
+  async getBalances(_address) {
     return [
       {
         token: "0xTokenA",
@@ -340,7 +340,7 @@ class DummyLpService extends Service2 {
     }
     return marketData;
   }
-  async swap(tokenIn, tokenOut, amountIn, minAmountOut, slippage) {
+  async swap(_tokenIn, _tokenOut, _amountIn, _minAmountOut, _slippage) {
     return {
       hash: "0xDummyHash",
       success: true
@@ -411,7 +411,7 @@ class DummyWalletService extends Service3 {
     const amountBigInt = BigInt(amount);
     const solBalance = this.balances.get("SOL") || BigInt(0);
     if (solBalance < amountBigInt) {
-      throw new Error(`Insufficient SOL balance`);
+      throw new Error("Insufficient SOL balance");
     }
     this.balances.set("SOL", solBalance - amountBigInt);
     return `dummy-tx-${Date.now()}`;
@@ -455,7 +455,7 @@ class DummyWalletService extends Service3 {
 }
 
 // src/pdf/service.ts
-import { Service as Service4, ServiceType, logger as logger3 } from "@elizaos/core";
+import { Service as Service4, ServiceType, logger as logger2 } from "@elizaos/core";
 
 class DummyPdfService extends Service4 {
   static serviceType = ServiceType.PDF;
@@ -469,13 +469,13 @@ class DummyPdfService extends Service4 {
     return service;
   }
   async initialize() {
-    logger3.info("DummyPdfService initialized");
+    logger2.info({ src: "plugin:dummy-services:pdf" }, "DummyPdfService initialized");
   }
   async stop() {
-    logger3.info("DummyPdfService stopped");
+    logger2.info({ src: "plugin:dummy-services:pdf" }, "DummyPdfService stopped");
   }
   async extractText(pdfBuffer) {
-    logger3.debug(`Extracting text from PDF (${pdfBuffer.length} bytes)`);
+    logger2.debug({ src: "plugin:dummy-services:pdf", bytes: pdfBuffer.length }, `Extracting text from PDF (${pdfBuffer.length} bytes)`);
     return {
       text: "This is dummy extracted text from the PDF document.",
       metadata: {
@@ -487,25 +487,25 @@ class DummyPdfService extends Service4 {
     };
   }
   async generatePdf(content, options) {
-    logger3.debug("Generating PDF", JSON.stringify(options));
+    logger2.debug({ src: "plugin:dummy-services:pdf", options }, "Generating PDF");
     const dummyPdf = Buffer.from("dummy-pdf-content");
-    logger3.debug(`Generated PDF: ${dummyPdf.length} bytes`);
+    logger2.debug({ src: "plugin:dummy-services:pdf", bytes: dummyPdf.length }, `Generated PDF: ${dummyPdf.length} bytes`);
     return dummyPdf;
   }
   async convertToPdf(input, inputFormat, options) {
-    logger3.debug(`Converting ${inputFormat} to PDF`, JSON.stringify(options));
+    logger2.debug({ src: "plugin:dummy-services:pdf", inputFormat, options }, `Converting ${inputFormat} to PDF`);
     const dummyPdf = Buffer.from(`dummy-pdf-from-${inputFormat}`);
-    logger3.debug(`Converted to PDF: ${dummyPdf.length} bytes`);
+    logger2.debug({ src: "plugin:dummy-services:pdf", bytes: dummyPdf.length }, `Converted to PDF: ${dummyPdf.length} bytes`);
     return dummyPdf;
   }
   async mergePdfs(pdfBuffers) {
-    logger3.debug(`Merging ${pdfBuffers.length} PDFs`);
+    logger2.debug({ src: "plugin:dummy-services:pdf", count: pdfBuffers.length }, `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`);
+    logger2.debug({ src: "plugin:dummy-services:pdf", parts: ranges.length }, `Splitting PDF into ${ranges.length} parts`);
     return ranges.map((range, index) => Buffer.from(`dummy-split-pdf-part-${index}-pages-${range[0]}-${range[1]}`));
   }
   getDexName() {
@@ -514,7 +514,7 @@ class DummyPdfService extends Service4 {
 }
 
 // src/video/service.ts
-import { Service as Service5, ServiceType as ServiceType2, logger as logger4 } from "@elizaos/core";
+import { Service as Service5, ServiceType as ServiceType2, logger as logger3 } from "@elizaos/core";
 
 class DummyVideoService extends Service5 {
   static serviceType = ServiceType2.VIDEO;
@@ -528,13 +528,13 @@ class DummyVideoService extends Service5 {
     return service;
   }
   async initialize() {
-    logger4.info("DummyVideoService initialized");
+    logger3.info({ src: "plugin:dummy-services:video" }, "DummyVideoService initialized");
   }
   async stop() {
-    logger4.info("DummyVideoService stopped");
+    logger3.info({ src: "plugin:dummy-services:video" }, "DummyVideoService stopped");
   }
   async getVideoInfo(url) {
-    logger4.debug(`Getting video info for: ${url}`);
+    logger3.debug({ src: "plugin:dummy-services:video", url }, `Getting video info for: ${url}`);
     return {
       title: "Dummy Video Title",
       duration: 300,
@@ -549,27 +549,27 @@ class DummyVideoService extends Service5 {
     };
   }
   async downloadVideo(url, options) {
-    logger4.debug(`Downloading video from: ${url}`, JSON.stringify(options));
+    logger3.debug({ src: "plugin:dummy-services:video", url, options }, `Downloading video from: ${url}`);
     const dummyVideo = Buffer.from(`dummy-video-${options?.format || "mp4"}`);
-    logger4.debug(`Downloaded video: ${dummyVideo.length} bytes`);
+    logger3.debug({ src: "plugin:dummy-services:video", bytes: dummyVideo.length }, `Downloaded video: ${dummyVideo.length} bytes`);
     return dummyVideo;
   }
   async extractAudio(videoBuffer) {
-    logger4.debug(`Extracting audio from video (${videoBuffer.length} bytes)`);
+    logger3.debug({ src: "plugin:dummy-services:video", bytes: videoBuffer.length }, `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`);
+    logger3.debug({ src: "plugin:dummy-services:video", frameCount: timestamps.length }, `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));
+    logger3.debug({ src: "plugin:dummy-services:video", options }, "Processing video");
     const processedVideo = Buffer.from(`dummy-processed-video-${options.outputFormat || "mp4"}`);
-    logger4.debug(`Processed video: ${processedVideo.length} bytes`);
+    logger3.debug({ src: "plugin:dummy-services:video", bytes: processedVideo.length }, `Processed video: ${processedVideo.length} bytes`);
     return processedVideo;
   }
   async getAvailableFormats(url) {
-    logger4.debug(`Getting available formats for: ${url}`);
+    logger3.debug({ src: "plugin:dummy-services:video", url }, `Getting available formats for: ${url}`);
     return [
       {
         format: "mp4",
@@ -597,7 +597,7 @@ class DummyVideoService extends Service5 {
 }
 
 // src/browser/service.ts
-import { Service as Service6, ServiceType as ServiceType3, logger as logger5 } from "@elizaos/core";
+import { Service as Service6, ServiceType as ServiceType3, logger as logger4 } from "@elizaos/core";
 
 class DummyBrowserService extends Service6 {
   static serviceType = ServiceType3.BROWSER;
@@ -614,15 +614,15 @@ class DummyBrowserService extends Service6 {
     return service;
   }
   async initialize() {
-    logger5.info("DummyBrowserService initialized");
+    logger4.info({ src: "plugin:dummy-services:browser" }, "DummyBrowserService initialized");
   }
   async stop() {
-    logger5.info("DummyBrowserService stopped");
+    logger4.info({ src: "plugin:dummy-services:browser" }, "DummyBrowserService stopped");
   }
   async navigate(url, options) {
-    logger5.debug(`Navigating to ${url}`);
+    logger4.debug({ src: "plugin:dummy-services:browser", url }, `Navigating to ${url}`);
     if (options) {
-      logger5.debug("Navigation options:", JSON.stringify(options));
+      logger4.debug({ src: "plugin:dummy-services:browser", options }, "Navigation options");
     }
     this.history.push(url);
     this.historyIndex = this.history.length - 1;
@@ -630,13 +630,13 @@ class DummyBrowserService extends Service6 {
     await new Promise((resolve) => setTimeout(resolve, 100));
   }
   async screenshot(options) {
-    logger5.debug("Taking screenshot", JSON.stringify(options));
+    logger4.debug({ src: "plugin:dummy-services:browser", options }, "Taking screenshot");
     const dummyImage = Buffer.from("dummy-screenshot-data");
-    logger5.debug(`Screenshot taken: ${dummyImage.length} bytes`);
+    logger4.debug({ src: "plugin:dummy-services:browser", bytes: dummyImage.length }, `Screenshot taken: ${dummyImage.length} bytes`);
     return dummyImage;
   }
   async extractContent(selectors) {
-    logger5.debug("Extracting content", JSON.stringify(selectors));
+    logger4.debug({ src: "plugin:dummy-services:browser", selectors }, "Extracting content");
     const dummyContent = [
       {
         text: "Dummy extracted text",
@@ -657,63 +657,63 @@ class DummyBrowserService extends Service6 {
     return dummyContent;
   }
   async waitForSelector(selector, timeout) {
-    logger5.debug(`Waiting for selector: ${selector.selector}`);
+    logger4.debug({ src: "plugin:dummy-services:browser", selector: selector.selector, timeout }, `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}`);
+    logger4.debug({ src: "plugin:dummy-services:browser", selector: selector.selector }, `Selector found: ${selector.selector}`);
     return true;
   }
   async click(selector, options) {
-    logger5.debug(`Clicking on: ${selector.selector}`, JSON.stringify(options));
+    logger4.debug({ src: "plugin:dummy-services:browser", selector: selector.selector, options }, `Clicking on: ${selector.selector}`);
     const delay = options?.delay || 50;
     await new Promise((resolve) => setTimeout(resolve, delay));
-    logger5.debug(`Clicked on: ${selector.selector}`);
+    logger4.debug({ src: "plugin:dummy-services:browser", selector: selector.selector }, `Clicked on: ${selector.selector}`);
   }
   async type(selector, text, options) {
-    logger5.debug(`Typing into: ${selector.selector}`, JSON.stringify(options));
+    logger4.debug({ src: "plugin:dummy-services:browser", selector: selector.selector, options }, `Typing into: ${selector.selector}`);
     const delay = options?.delay || 50;
     await new Promise((resolve) => setTimeout(resolve, text.length * delay));
-    logger5.debug(`Typed "${text}" into: ${selector.selector}`);
+    logger4.debug({ src: "plugin:dummy-services:browser", selector: selector.selector, text }, `Typed "${text}" into: ${selector.selector}`);
   }
   async evaluateScript(script) {
-    logger5.debug("Evaluating script:", script.substring(0, 100) + "...");
+    logger4.debug({ src: "plugin:dummy-services:browser", scriptPreview: script.substring(0, 100) }, `Evaluating script: ${script.substring(0, 100)}...`);
     return { success: true, data: "dummy-script-result" };
   }
   async goBack() {
     if (this.historyIndex > 0) {
       this.historyIndex--;
       this.currentUrl = this.history[this.historyIndex];
-      logger5.debug(`Navigated back to: ${this.currentUrl}`);
+      logger4.debug({ src: "plugin:dummy-services:browser", url: this.currentUrl }, `Navigated back to: ${this.currentUrl}`);
     }
   }
   async goForward() {
     if (this.historyIndex < this.history.length - 1) {
       this.historyIndex++;
       this.currentUrl = this.history[this.historyIndex];
-      logger5.debug(`Navigated forward to: ${this.currentUrl}`);
+      logger4.debug({ src: "plugin:dummy-services:browser", url: this.currentUrl }, `Navigated forward to: ${this.currentUrl}`);
     }
   }
   async refresh() {
-    logger5.debug(`Refreshing page: ${this.currentUrl}`);
+    logger4.debug({ src: "plugin:dummy-services:browser", url: this.currentUrl }, `Refreshing page: ${this.currentUrl}`);
     await new Promise((resolve) => setTimeout(resolve, 100));
   }
   async getUrl() {
-    logger5.debug(`Current URL: ${this.currentUrl}`);
+    logger4.debug({ src: "plugin:dummy-services:browser", url: this.currentUrl }, `Current URL: ${this.currentUrl}`);
     return this.currentUrl;
   }
   async getTitle() {
-    logger5.debug("Getting page title");
+    logger4.debug({ src: "plugin:dummy-services:browser" }, "Getting page title");
     return `Dummy Title - ${this.currentUrl}`;
   }
   async setCookies(cookies) {
-    logger5.debug(`Setting ${cookies.length} cookies`);
+    logger4.debug({ src: "plugin:dummy-services:browser", count: cookies.length }, `Setting ${cookies.length} cookies`);
   }
   async getCookies() {
-    logger5.debug("Getting cookies");
+    logger4.debug({ src: "plugin:dummy-services:browser" }, "Getting cookies");
     return [];
   }
   async clearCookies() {
-    logger5.debug("Clearing cookies");
+    logger4.debug({ src: "plugin:dummy-services:browser" }, "Clearing cookies");
   }
   getDexName() {
     return "dummy-browser";
@@ -721,7 +721,7 @@ class DummyBrowserService extends Service6 {
 }
 
 // src/transcription/service.ts
-import { Service as Service7, ServiceType as ServiceType4, logger as logger6 } from "@elizaos/core";
+import { Service as Service7, ServiceType as ServiceType4, logger as logger5 } from "@elizaos/core";
 
 class DummyTranscriptionService extends Service7 {
   static serviceType = ServiceType4.TRANSCRIPTION;
@@ -735,13 +735,13 @@ class DummyTranscriptionService extends Service7 {
     return service;
   }
   async initialize() {
-    logger6.info("DummyTranscriptionService initialized");
+    logger5.info({ src: "plugin:dummy-services:transcription" }, "DummyTranscriptionService initialized");
   }
   async stop() {
-    logger6.info("DummyTranscriptionService stopped");
+    logger5.info({ src: "plugin:dummy-services:transcription" }, "DummyTranscriptionService stopped");
   }
   async transcribeAudio(audioBuffer, options) {
-    logger6.debug(`Transcribing audio (${audioBuffer.length} bytes)`, JSON.stringify(options));
+    logger5.debug({ src: "plugin:dummy-services:transcription", bytes: audioBuffer.length, options }, `Transcribing audio (${audioBuffer.length} bytes)`);
     const segments = [
       {
         id: 0,
@@ -779,35 +779,35 @@ class DummyTranscriptionService extends Service7 {
       segments: options?.timestamps ? segments : undefined,
       words: options?.timestamps ? words : undefined
     };
-    logger6.debug(`Transcription complete: ${result.text.substring(0, 50)}...`);
+    logger5.debug({ src: "plugin:dummy-services:transcription", preview: result.text.substring(0, 50) }, `Transcription complete: ${result.text.substring(0, 50)}...`);
     return result;
   }
   async transcribeVideo(videoBuffer, options) {
-    logger6.debug(`Transcribing video (${videoBuffer.length} bytes)`, JSON.stringify(options));
+    logger5.debug({ src: "plugin:dummy-services:transcription", bytes: videoBuffer.length, options }, `Transcribing video (${videoBuffer.length} bytes)`);
     return this.transcribeAudio(videoBuffer, options);
   }
   async speechToText(audioBuffer, options) {
-    logger6.debug("Converting speech to text", JSON.stringify(options));
+    logger5.debug({ src: "plugin:dummy-services:transcription", options }, "Converting speech to text");
     const result = await this.transcribeAudio(audioBuffer, options);
-    logger6.debug(`Speech to text complete: ${result.text.substring(0, 50)}...`);
+    logger5.debug({ src: "plugin:dummy-services:transcription", preview: result.text.substring(0, 50) }, `Speech to text complete: ${result.text.substring(0, 50)}...`);
     if (options?.format === "text" || !options?.format) {
       return result.text;
     }
     return result;
   }
   async textToSpeech(text, options) {
-    logger6.debug(`Converting text to speech: "${text.substring(0, 50)}..."`, JSON.stringify(options));
+    logger5.debug({ src: "plugin:dummy-services:transcription", textPreview: text.substring(0, 50), options }, `Converting text to speech: "${text.substring(0, 50)}..."`);
     const format = options?.format || "mp3";
     const dummyAudio = Buffer.from(`dummy-audio-${format}-${text.length}-chars`);
-    logger6.debug(`Generated ${format} audio: ${dummyAudio.length} bytes`);
+    logger5.debug({ src: "plugin:dummy-services:transcription", format, bytes: dummyAudio.length }, `Generated ${format} audio: ${dummyAudio.length} bytes`);
     return dummyAudio;
   }
   async detectLanguage(audioBuffer) {
-    logger6.debug(`Detecting language from audio (${audioBuffer.length} bytes)`);
+    logger5.debug({ src: "plugin:dummy-services:transcription", bytes: audioBuffer.length }, `Detecting language from audio (${audioBuffer.length} bytes)`);
     return "en";
   }
   async translateAudio(audioBuffer, targetLanguage, sourceLanguage) {
-    logger6.debug(`Translating audio to ${targetLanguage}`, JSON.stringify({ sourceLanguage }));
+    logger5.debug({ src: "plugin:dummy-services:transcription", targetLanguage, sourceLanguage }, `Translating audio to ${targetLanguage}`);
     return {
       text: `This is dummy translated text in ${targetLanguage}.`,
       language: targetLanguage,
@@ -820,7 +820,7 @@ class DummyTranscriptionService extends Service7 {
 }
 
 // src/web-search/service.ts
-import { Service as Service8, ServiceType as ServiceType5, logger as logger7 } from "@elizaos/core";
+import { Service as Service8, ServiceType as ServiceType5, logger as logger6 } from "@elizaos/core";
 
 class DummyWebSearchService extends Service8 {
   static serviceType = ServiceType5.WEB_SEARCH;
@@ -834,16 +834,16 @@ class DummyWebSearchService extends Service8 {
     return service;
   }
   async initialize() {
-    logger7.info("DummyWebSearchService initialized");
+    logger6.info({ src: "plugin:dummy-services:web-search" }, "DummyWebSearchService initialized");
   }
   async stop() {
-    logger7.info("DummyWebSearchService stopped");
+    logger6.info({ src: "plugin:dummy-services:web-search" }, "DummyWebSearchService stopped");
   }
   async search(options) {
-    logger7.debug("Performing web search", JSON.stringify(options));
+    logger6.debug({ src: "plugin:dummy-services:web-search", options }, "Performing web search");
     const limit = options.limit || 10;
     const results = [];
-    logger7.debug(`Generating ${limit} dummy search results for: ${options.query}`);
+    logger6.debug({ src: "plugin:dummy-services:web-search", limit, query: options.query }, `Generating ${limit} dummy search results for: ${options.query}`);
     for (let i = 0;i < limit; i++) {
       results.push({
         title: `Result ${i + 1}: ${options.query}`,
@@ -862,10 +862,10 @@ class DummyWebSearchService extends Service8 {
     };
   }
   async searchNews(options) {
-    logger7.debug("Performing news search", JSON.stringify(options));
+    logger6.debug({ src: "plugin:dummy-services:web-search", options }, "Performing news search");
     const limit = options.limit || 10;
     const results = [];
-    logger7.debug(`Generating ${limit} dummy news results for: ${options.query}`);
+    logger6.debug({ src: "plugin:dummy-services:web-search", limit, query: options.query }, `Generating ${limit} dummy news results for: ${options.query}`);
     for (let i = 0;i < limit; i++) {
       results.push({
         title: `News: ${options.query} - Article ${i + 1}`,
@@ -885,10 +885,10 @@ class DummyWebSearchService extends Service8 {
     };
   }
   async searchImages(options) {
-    logger7.debug("Performing image search", JSON.stringify(options));
+    logger6.debug({ src: "plugin:dummy-services:web-search", options }, "Performing image search");
     const limit = options.limit || 10;
     const results = [];
-    logger7.debug(`Generating ${limit} dummy image results for: ${options.query}`);
+    logger6.debug({ src: "plugin:dummy-services:web-search", limit, query: options.query }, `Generating ${limit} dummy image results for: ${options.query}`);
     for (let i = 0;i < limit; i++) {
       results.push({
         title: `Image: ${options.query} - ${i + 1}`,
@@ -908,10 +908,10 @@ class DummyWebSearchService extends Service8 {
     };
   }
   async searchVideos(options) {
-    logger7.debug("Performing video search", JSON.stringify(options));
+    logger6.debug({ src: "plugin:dummy-services:web-search", options }, "Performing video search");
     const limit = options.limit || 10;
     const results = [];
-    logger7.debug(`Generating ${limit} dummy video results for: ${options.query}`);
+    logger6.debug({ src: "plugin:dummy-services:web-search", limit, query: options.query }, `Generating ${limit} dummy video results for: ${options.query}`);
     for (let i = 0;i < limit; i++) {
       results.push({
         title: `Video: ${options.query} - Part ${i + 1}`,
@@ -932,7 +932,7 @@ class DummyWebSearchService extends Service8 {
     };
   }
   async autocomplete(query) {
-    logger7.debug(`Getting autocomplete suggestions for: ${query}`);
+    logger6.debug({ src: "plugin:dummy-services:web-search", query }, `Getting autocomplete suggestions for: ${query}`);
     return [
       `${query} tutorial`,
       `${query} examples`,
@@ -945,7 +945,7 @@ class DummyWebSearchService extends Service8 {
     ];
   }
   async getTrendingSearches(region) {
-    logger7.debug(`Getting trending searches for region: ${region || "global"}`);
+    logger6.debug({ src: "plugin:dummy-services:web-search", region: region || "global" }, `Getting trending searches for region: ${region || "global"}`);
     return [
       "artificial intelligence",
       "machine learning",
@@ -958,7 +958,7 @@ class DummyWebSearchService extends Service8 {
     ];
   }
   async getRelatedSearches(query) {
-    logger7.debug(`Getting related searches for: ${query}`);
+    logger6.debug({ src: "plugin:dummy-services:web-search", query }, `Getting related searches for: ${query}`);
     return [
       `${query} alternatives`,
       `${query} vs competitors`,
@@ -976,7 +976,7 @@ class DummyWebSearchService extends Service8 {
 }
 
 // src/email/service.ts
-import { Service as Service9, ServiceType as ServiceType6, logger as logger8 } from "@elizaos/core";
+import { Service as Service9, ServiceType as ServiceType6, logger as logger7 } from "@elizaos/core";
 
 class DummyEmailService extends Service9 {
   static serviceType = ServiceType6.EMAIL;
@@ -995,16 +995,16 @@ class DummyEmailService extends Service9 {
     return service;
   }
   async initialize() {
-    logger8.info("DummyEmailService initialized");
+    logger7.info({ src: "plugin:dummy-services:email" }, "DummyEmailService initialized");
   }
   async stop() {
-    logger8.info("DummyEmailService stopped");
+    logger7.info({ src: "plugin:dummy-services:email" }, "DummyEmailService stopped");
   }
   async sendEmail(to, subject, body, options) {
-    logger8.debug("Sending email", JSON.stringify({ to, subject }));
-    logger8.debug("Email options:", JSON.stringify(options));
+    logger7.debug({ src: "plugin:dummy-services:email", to, subject }, "Sending email");
+    logger7.debug({ src: "plugin:dummy-services:email", options }, "Email options");
     const messageId = `dummy-${Date.now()}@example.com`;
-    logger8.info(`Email sent successfully. Message ID: ${messageId}`);
+    logger7.info({ src: "plugin:dummy-services:email", messageId }, `Email sent successfully. Message ID: ${messageId}`);
     const sentEmail = {
       id: messageId,
       from: { address: "dummy@example.com", name: "Dummy Sender" },
@@ -1022,7 +1022,7 @@ class DummyEmailService extends Service9 {
     return messageId;
   }
   async searchEmails(options) {
-    logger8.debug("Searching emails", JSON.stringify(options));
+    logger7.debug({ src: "plugin:dummy-services:email", options }, "Searching emails");
     let results = this.emails;
     if (options) {
       if (options.from) {
@@ -1035,16 +1035,16 @@ class DummyEmailService extends Service9 {
         results = results.slice(0, options.limit);
       }
     }
-    logger8.debug(`Found ${results.length} emails`);
+    logger7.debug({ src: "plugin:dummy-services:email", count: results.length }, `Found ${results.length} emails`);
     return results;
   }
   async getEmail(messageId) {
-    logger8.debug(`Getting email: ${messageId}`);
+    logger7.debug({ src: "plugin:dummy-services:email", messageId }, `Getting email: ${messageId}`);
     const email = this.emails.find((e) => e.id === messageId);
     return email || null;
   }
   async deleteEmail(messageId) {
-    logger8.debug(`Deleting email: ${messageId}`);
+    logger7.debug({ src: "plugin:dummy-services:email", messageId }, `Deleting email: ${messageId}`);
     const index = this.emails.findIndex((e) => e.id === messageId);
     if (index !== -1) {
       this.emails.splice(index, 1);
@@ -1053,23 +1053,23 @@ class DummyEmailService extends Service9 {
     return false;
   }
   async markAsRead(messageId) {
-    logger8.debug(`Marking email as read: ${messageId}`);
+    logger7.debug({ src: "plugin:dummy-services:email", messageId }, `Marking email as read: ${messageId}`);
     return true;
   }
   async markAsUnread(messageId) {
-    logger8.debug(`Marking email as unread: ${messageId}`);
+    logger7.debug({ src: "plugin:dummy-services:email", messageId }, `Marking email as unread: ${messageId}`);
     return true;
   }
   async moveToFolder(messageId, folderPath) {
-    logger8.debug(`Moving email ${messageId} to folder: ${folderPath}`);
+    logger7.debug({ src: "plugin:dummy-services:email", messageId, folderPath }, `Moving email ${messageId} to folder: ${folderPath}`);
     return true;
   }
   async getFolders() {
-    logger8.debug("Getting email folders");
+    logger7.debug({ src: "plugin:dummy-services:email" }, "Getting email folders");
     return this.folders;
   }
   async createFolder(name, parentPath) {
-    logger8.debug(`Creating folder: ${name}`, JSON.stringify({ parentPath }));
+    logger7.debug({ src: "plugin:dummy-services:email", name, parentPath }, `Creating folder: ${name}`);
     const path = parentPath ? `${parentPath}/${name}` : name;
     const folder = {
       name,
@@ -1081,7 +1081,7 @@ class DummyEmailService extends Service9 {
     return folder;
   }
   async deleteFolder(folderPath) {
-    logger8.debug(`Deleting folder: ${folderPath}`);
+    logger7.debug({ src: "plugin:dummy-services:email", folderPath }, `Deleting folder: ${folderPath}`);
     const index = this.folders.findIndex((f) => f.path === folderPath);
     if (index !== -1) {
       this.folders.splice(index, 1);
@@ -1090,15 +1090,15 @@ class DummyEmailService extends Service9 {
     return false;
   }
   async replyToEmail(messageId, body, options) {
-    logger8.debug(`Replying to email: ${messageId}`, JSON.stringify(options));
+    logger7.debug({ src: "plugin:dummy-services:email", messageId, options }, `Replying to email: ${messageId}`);
     const replyMessageId = `dummy-reply-${Date.now()}@example.com`;
-    logger8.info(`Reply sent successfully. Message ID: ${replyMessageId}`);
+    logger7.info({ src: "plugin:dummy-services:email", replyMessageId }, `Reply sent successfully. Message ID: ${replyMessageId}`);
     return replyMessageId;
   }
   async forwardEmail(messageId, to, options) {
-    logger8.debug(`Forwarding email: ${messageId}`, JSON.stringify({ to, options }));
+    logger7.debug({ src: "plugin:dummy-services:email", messageId, to, options }, `Forwarding email: ${messageId}`);
     const forwardMessageId = `dummy-forward-${Date.now()}@example.com`;
-    logger8.info(`Email forwarded successfully. Message ID: ${forwardMessageId}`);
+    logger7.info({ src: "plugin:dummy-services:email", forwardMessageId }, `Email forwarded successfully. Message ID: ${forwardMessageId}`);
     return forwardMessageId;
   }
   getDexName() {
@@ -1107,14 +1107,14 @@ class DummyEmailService extends Service9 {
 }
 
 // src/e2e/scenarios.ts
-import { logger as logger9 } from "@elizaos/core";
+import { logger as logger8 } from "@elizaos/core";
 var dummyServicesScenariosSuite = {
   name: "Dummy Services E2E Tests",
   tests: [
     {
       name: "Dummy test placeholder",
-      async fn(runtime) {
-        logger9.info("Dummy services test placeholder");
+      async fn(_runtime) {
+        logger8.info({ src: "plugin:dummy-services:e2e" }, "Dummy services test placeholder");
       }
     }
   ]
@@ -1136,7 +1136,7 @@ var dummyServicesPlugin = {
     DummyEmailService
   ],
   tests: [dummyServicesScenariosSuite],
-  init: async (runtime) => {
+  init: async (_runtime) => {
     console.log("Dummy Services Plugin Initialized");
   }
 };
@@ -1155,5 +1155,5 @@ export {
   DummyBrowserService
 };
 
-//# debugId=6F637A989CA848D464756E2164756E21
+//# debugId=EF0ABC99094C4FC864756E2164756E21
 //# sourceMappingURL=index.js.map