@elizaos/plugin-bootstrap 1.4.2 → 1.4.4

package/dist/index.js

@@ -71,16 +71,16 @@ var require_dedent = __commonJS({
 
 // src/index.ts
 import {
-  asUUID,
+  asUUID as asUUID2,
   ChannelType as ChannelType9,
   composePromptFromState as composePromptFromState10,
   ContentType as ContentType2,
   createUniqueUuid as createUniqueUuid3,
-  EventType,
+  EventType as EventType2,
   imageDescriptionTemplate,
-  logger as logger20,
+  logger as logger21,
   messageHandlerTemplate,
-  ModelType as ModelType14,
+  ModelType as ModelType15,
   parseKeyValueXml as parseKeyValueXml9,
   postCreationTemplate,
   parseBooleanFromText as parseBooleanFromText2,
@@ -4561,7 +4561,7 @@ var updateEntityAction = {
 
 // src/evaluators/reflection.ts
 import { z } from "zod";
-import { getEntityDetails, logger as logger10, parseKeyValueXml as parseKeyValueXml8 } from "@elizaos/core";
+import { asUUID, getEntityDetails, logger as logger10, parseKeyValueXml as parseKeyValueXml8 } from "@elizaos/core";
 import { composePrompt as composePrompt4 } from "@elizaos/core";
 import {
   ModelType as ModelType12
@@ -4723,14 +4723,18 @@ async function handler(runtime, message, state) {
     ) || [];
     await Promise.all(
       newFacts.map(async (fact) => {
-        const factMemory = await runtime.addEmbeddingToMemory({
+        const factMemory = {
+          id: asUUID(v4_default()),
           entityId: agentId,
           agentId,
           content: { text: fact.claim },
           roomId,
           createdAt: Date.now()
-        });
-        return runtime.createMemory(factMemory, "facts", true);
+        };
+        const createdMemoryId = await runtime.createMemory(factMemory, "facts", true);
+        const createdMemory = { ...factMemory, id: createdMemoryId };
+        await runtime.queueEmbeddingGeneration(createdMemory, "low");
+        return createdMemory;
       })
     );
     let relationshipsArray = [];
@@ -6895,6 +6899,245 @@ var TaskService = class _TaskService extends Service {
   }
 };
 
+// src/services/embedding.ts
+import {
+  Service as Service2,
+  EventType,
+  ModelType as ModelType14,
+  logger as logger20
+} from "@elizaos/core";
+var EmbeddingGenerationService = class _EmbeddingGenerationService extends Service2 {
+  static serviceType = "embedding-generation";
+  capabilityDescription = "Handles asynchronous embedding generation for memories";
+  queue = [];
+  isProcessing = false;
+  processingInterval = null;
+  maxQueueSize = 1e3;
+  batchSize = 10;
+  // Process up to 10 embeddings at a time
+  processingIntervalMs = 100;
+  // Check queue every 100ms
+  static async start(runtime) {
+    logger20.info("[EmbeddingService] Starting embedding generation service");
+    const service = new _EmbeddingGenerationService(runtime);
+    await service.initialize();
+    return service;
+  }
+  async initialize() {
+    logger20.info("[EmbeddingService] Initializing embedding generation service");
+    this.runtime.registerEvent(
+      EventType.EMBEDDING_GENERATION_REQUESTED,
+      this.handleEmbeddingRequest.bind(this)
+    );
+    this.startProcessing();
+  }
+  async handleEmbeddingRequest(payload) {
+    const { memory, priority = "normal", retryCount = 0, maxRetries = 3 } = payload;
+    if (memory.embedding) {
+      logger20.debug("[EmbeddingService] Memory already has embeddings, skipping");
+      return;
+    }
+    if (this.queue.length >= this.maxQueueSize) {
+      logger20.warn(
+        `[EmbeddingService] Queue is full (${this.queue.length}/${this.maxQueueSize}), making room`
+      );
+      this.makeRoomInQueue();
+    }
+    const queueItem = {
+      memory,
+      priority,
+      retryCount,
+      maxRetries,
+      addedAt: Date.now()
+    };
+    this.insertItemByPriority(queueItem);
+    logger20.debug(`[EmbeddingService] Added memory to queue. Queue size: ${this.queue.length}`);
+  }
+  /**
+   * Make room in the queue by removing items based on priority and age
+   * Removes 10% of the queue (minimum 1, maximum 10 items)
+   */
+  makeRoomInQueue() {
+    const tenPercent = Math.floor(this.maxQueueSize * 0.1);
+    const itemsToRemove = Math.min(10, Math.max(1, tenPercent));
+    const itemsWithIndex = this.queue.map((item, index) => ({ item, originalIndex: index }));
+    itemsWithIndex.sort((a2, b) => {
+      const priorityOrder = { low: 0, normal: 1, high: 2 };
+      const priorityDiff = priorityOrder[a2.item.priority] - priorityOrder[b.item.priority];
+      if (priorityDiff !== 0) return priorityDiff;
+      return a2.item.addedAt - b.item.addedAt;
+    });
+    const indicesToRemove = new Set(
+      itemsWithIndex.slice(0, Math.min(itemsToRemove, itemsWithIndex.length)).map(({ originalIndex }) => originalIndex)
+    );
+    const newQueue = this.queue.filter((_, index) => !indicesToRemove.has(index));
+    const removedCount = this.queue.length - newQueue.length;
+    this.queue = newQueue;
+    logger20.info(
+      `[EmbeddingService] Removed ${removedCount} items from queue. New size: ${this.queue.length}`
+    );
+  }
+  /**
+   * Insert an item into the queue based on its priority
+   * High priority items go to the front, normal in the middle, low at the end
+   */
+  insertItemByPriority(queueItem) {
+    if (queueItem.priority === "high") {
+      let insertIndex = 0;
+      for (let i2 = 0; i2 < this.queue.length; i2++) {
+        if (this.queue[i2].priority !== "high") break;
+        insertIndex = i2 + 1;
+      }
+      this.queue.splice(insertIndex, 0, queueItem);
+    } else if (queueItem.priority === "low") {
+      this.queue.push(queueItem);
+    } else {
+      let insertIndex = 0;
+      for (let i2 = 0; i2 < this.queue.length; i2++) {
+        if (this.queue[i2].priority !== "high") {
+          insertIndex = i2;
+          break;
+        }
+        insertIndex = i2 + 1;
+      }
+      for (let i2 = insertIndex; i2 < this.queue.length; i2++) {
+        if (this.queue[i2].priority === "low") {
+          insertIndex = i2;
+          break;
+        }
+        insertIndex = i2 + 1;
+      }
+      this.queue.splice(insertIndex, 0, queueItem);
+    }
+  }
+  startProcessing() {
+    if (this.processingInterval) {
+      return;
+    }
+    this.processingInterval = setInterval(async () => {
+      if (!this.isProcessing && this.queue.length > 0) {
+        await this.processQueue();
+      }
+    }, this.processingIntervalMs);
+    logger20.info("[EmbeddingService] Started processing loop");
+  }
+  async processQueue() {
+    if (this.isProcessing || this.queue.length === 0) {
+      return;
+    }
+    this.isProcessing = true;
+    try {
+      const batch = this.queue.splice(0, Math.min(this.batchSize, this.queue.length));
+      logger20.debug(
+        `[EmbeddingService] Processing batch of ${batch.length} items. Remaining in queue: ${this.queue.length}`
+      );
+      const promises = batch.map(async (item) => {
+        try {
+          await this.generateEmbedding(item);
+        } catch (error) {
+          logger20.error(
+            { error, memoryId: item.memory.id },
+            "[EmbeddingService] Error processing item:"
+          );
+          if (item.retryCount < item.maxRetries) {
+            item.retryCount++;
+            this.insertItemByPriority(item);
+            logger20.debug(
+              `[EmbeddingService] Re-queued item for retry (${item.retryCount}/${item.maxRetries})`
+            );
+          } else {
+            await this.runtime.emitEvent(EventType.EMBEDDING_GENERATION_FAILED, {
+              runtime: this.runtime,
+              memory: item.memory,
+              error: error instanceof Error ? error.message : String(error),
+              source: "embeddingService"
+            });
+          }
+        }
+      });
+      await Promise.all(promises);
+    } finally {
+      this.isProcessing = false;
+    }
+  }
+  async generateEmbedding(item) {
+    const { memory } = item;
+    if (!memory.content?.text) {
+      logger20.warn({ memoryId: memory.id }, "[EmbeddingService] Memory has no text content");
+      return;
+    }
+    try {
+      const startTime = Date.now();
+      const embedding = await this.runtime.useModel(ModelType14.TEXT_EMBEDDING, {
+        text: memory.content.text
+      });
+      const duration = Date.now() - startTime;
+      logger20.debug(
+        `[EmbeddingService] Generated embedding in ${duration}ms for memory ${memory.id}`
+      );
+      if (memory.id) {
+        await this.runtime.updateMemory({
+          id: memory.id,
+          embedding
+        });
+        await this.runtime.emitEvent(EventType.EMBEDDING_GENERATION_COMPLETED, {
+          runtime: this.runtime,
+          memory: { ...memory, embedding },
+          source: "embeddingService"
+        });
+      }
+    } catch (error) {
+      logger20.error(
+        { error, memoryId: memory.id },
+        "[EmbeddingService] Failed to generate embedding:"
+      );
+      throw error;
+    }
+  }
+  async stop() {
+    logger20.info("[EmbeddingService] Stopping embedding generation service");
+    if (this.processingInterval) {
+      clearInterval(this.processingInterval);
+      this.processingInterval = null;
+    }
+    const highPriorityItems = this.queue.filter((item) => item.priority === "high");
+    if (highPriorityItems.length > 0) {
+      logger20.info(
+        `[EmbeddingService] Processing ${highPriorityItems.length} high priority items before shutdown`
+      );
+      for (const item of highPriorityItems) {
+        try {
+          await this.generateEmbedding(item);
+        } catch (error) {
+          logger20.error({ error }, "[EmbeddingService] Error during shutdown processing:");
+        }
+      }
+    }
+    logger20.info(`[EmbeddingService] Stopped. ${this.queue.length} items remaining in queue`);
+  }
+  // Public methods for monitoring
+  getQueueSize() {
+    return this.queue.length;
+  }
+  getQueueStats() {
+    const stats = {
+      high: 0,
+      normal: 0,
+      low: 0,
+      total: this.queue.length
+    };
+    for (const item of this.queue) {
+      stats[item.priority]++;
+    }
+    return stats;
+  }
+  clearQueue() {
+    const size = this.queue.length;
+    this.queue = [];
+    logger20.info(`[EmbeddingService] Cleared ${size} items from queue`);
+  }
+};
+
 // src/index.ts
 var latestResponseIds = /* @__PURE__ */ new Map();
 async function fetchMediaData(attachments) {
@@ -6936,21 +7179,36 @@ async function processAttachments(attachments, runtime) {
           imageUrl = `data:${contentType};base64,${buffer.toString("base64")}`;
         }
         try {
-          const response = await runtime.useModel(ModelType14.IMAGE_DESCRIPTION, {
+          const response = await runtime.useModel(ModelType15.IMAGE_DESCRIPTION, {
             prompt: imageDescriptionTemplate,
             imageUrl
           });
           if (typeof response === "string") {
             const parsedXml = parseKeyValueXml9(response);
-            if (parsedXml?.description && parsedXml?.text) {
-              processedAttachment.description = parsedXml.description;
+            if (parsedXml && (parsedXml.description || parsedXml.text)) {
+              processedAttachment.description = parsedXml.description || "";
               processedAttachment.title = parsedXml.title || "Image";
-              processedAttachment.text = parsedXml.text;
+              processedAttachment.text = parsedXml.text || parsedXml.description || "";
               runtime.logger.debug(
                 `[Bootstrap] Generated description: ${processedAttachment.description?.substring(0, 100)}...`
               );
             } else {
-              runtime.logger.warn(`[Bootstrap] Failed to parse XML response for image description`);
+              const responseStr = response;
+              const titleMatch = responseStr.match(/<title>([^<]+)<\/title>/);
+              const descMatch = responseStr.match(/<description>([^<]+)<\/description>/);
+              const textMatch = responseStr.match(/<text>([^<]+)<\/text>/);
+              if (titleMatch || descMatch || textMatch) {
+                processedAttachment.title = titleMatch?.[1] || "Image";
+                processedAttachment.description = descMatch?.[1] || "";
+                processedAttachment.text = textMatch?.[1] || descMatch?.[1] || "";
+                runtime.logger.debug(
+                  `[Bootstrap] Used fallback XML parsing - description: ${processedAttachment.description?.substring(0, 100)}...`
+                );
+              } else {
+                runtime.logger.warn(
+                  `[Bootstrap] Failed to parse XML response for image description`
+                );
+              }
             }
           } else if (response && typeof response === "object" && "description" in response) {
             processedAttachment.description = response.description;
@@ -7045,14 +7303,14 @@ var messageReceivedHandler = async ({
     }
     const previousResponseId = agentResponses.get(message.roomId);
     if (previousResponseId) {
-      logger20.warn(
+      logger21.warn(
         `[Bootstrap] Updating response ID for room ${message.roomId} from ${previousResponseId} to ${responseId} - this may discard in-progress responses`
       );
     }
     agentResponses.set(message.roomId, responseId);
     const runId = runtime.startRun();
     const startTime = Date.now();
-    await runtime.emitEvent(EventType.RUN_STARTED, {
+    await runtime.emitEvent(EventType2.RUN_STARTED, {
       runtime,
       runId,
       messageId: message.id,
@@ -7067,7 +7325,7 @@ var messageReceivedHandler = async ({
     });
     const timeoutPromise = new Promise((_, reject) => {
       timeoutId = setTimeout(async () => {
-        await runtime.emitEvent(EventType.RUN_TIMEOUT, {
+        await runtime.emitEvent(EventType2.RUN_TIMEOUT, {
           runtime,
           runId,
           messageId: message.id,
@@ -7092,23 +7350,23 @@ var messageReceivedHandler = async ({
         runtime.logger.debug(
           `[Bootstrap] Processing message: ${truncateToCompleteSentence(message.content.text || "", 50)}...`
         );
-        runtime.logger.debug("[Bootstrap] Saving message to memory and embeddings");
+        runtime.logger.debug("[Bootstrap] Saving message to memory and queueing embeddings");
+        let memoryToQueue;
         if (message.id) {
           const existingMemory = await runtime.getMemoryById(message.id);
           if (existingMemory) {
             runtime.logger.debug("[Bootstrap] Memory already exists, skipping creation");
-            await runtime.addEmbeddingToMemory(message);
+            memoryToQueue = existingMemory;
           } else {
-            await Promise.all([
-              runtime.addEmbeddingToMemory(message),
-              runtime.createMemory(message, "messages")
-            ]);
+            const createdMemoryId = await runtime.createMemory(message, "messages");
+            memoryToQueue = { ...message, id: createdMemoryId };
           }
+          await runtime.queueEmbeddingGeneration(memoryToQueue, "high");
         } else {
-          await Promise.all([
-            runtime.addEmbeddingToMemory(message),
-            runtime.createMemory(message, "messages")
-          ]);
+          const memoryId = await runtime.createMemory(message, "messages");
+          message.id = memoryId;
+          memoryToQueue = { ...message, id: memoryId };
+          await runtime.queueEmbeddingGeneration(memoryToQueue, "normal");
         }
         const agentUserState = await runtime.getParticipantUserState(
           message.roomId,
@@ -7117,7 +7375,7 @@ var messageReceivedHandler = async ({
         const defLllmOff = parseBooleanFromText2(runtime.getSetting("BOOTSTRAP_DEFLLMOFF"));
         if (defLllmOff && agentUserState === null) {
           runtime.logger.debug("bootstrap - LLM is off by default");
-          await runtime.emitEvent(EventType.RUN_ENDED, {
+          await runtime.emitEvent(EventType2.RUN_ENDED, {
             runtime,
             runId,
             messageId: message.id,
@@ -7133,7 +7391,7 @@ var messageReceivedHandler = async ({
         }
         if (agentUserState === "MUTED" && !message.content.text?.toLowerCase().includes(runtime.character.name.toLowerCase())) {
           runtime.logger.debug(`[Bootstrap] Ignoring muted room ${message.roomId}`);
-          await runtime.emitEvent(EventType.RUN_ENDED, {
+          await runtime.emitEvent(EventType2.RUN_ENDED, {
             runtime,
             runId,
             messageId: message.id,
@@ -7180,7 +7438,7 @@ var messageReceivedHandler = async ({
             `[Bootstrap] Evaluating response for ${runtime.character.name}
 Prompt: ${shouldRespondPrompt}`
           );
-          const response = await runtime.useModel(ModelType14.TEXT_SMALL, {
+          const response = await runtime.useModel(ModelType15.TEXT_SMALL, {
             prompt: shouldRespondPrompt
           });
           runtime.logger.debug(
@@ -7214,7 +7472,7 @@ ${response}`
           let retries = 0;
           const maxRetries = 3;
           while (retries < maxRetries && (!responseContent?.thought || !responseContent?.actions)) {
-            let response = await runtime.useModel(ModelType14.TEXT_LARGE, {
+            let response = await runtime.useModel(ModelType15.TEXT_LARGE, {
               prompt
             });
             runtime.logger.debug({ response }, "[Bootstrap] *** Raw LLM Response ***");
@@ -7272,7 +7530,7 @@ ${response}`
             const isSimple = responseContent.actions?.length === 1 && typeof responseContent.actions[0] === "string" && responseContent.actions[0].toUpperCase() === "REPLY" && (!responseContent.providers || responseContent.providers.length === 0);
             responseContent.simple = isSimple;
             const responseMessage = {
-              id: asUUID(v4_default()),
+              id: asUUID2(v4_default()),
               entityId: runtime.agentId,
               agentId: runtime.agentId,
               content: responseContent,
@@ -7328,7 +7586,7 @@ ${response}`
             runtime.logger.info(
               `Ignore response discarded - newer message being processed for agent: ${runtime.agentId}, room: ${message.roomId}`
             );
-            await runtime.emitEvent(EventType.RUN_ENDED, {
+            await runtime.emitEvent(EventType2.RUN_ENDED, {
               runtime,
               runId,
               messageId: message.id,
@@ -7346,7 +7604,7 @@ ${response}`
             runtime.logger.error(
               "[Bootstrap] Message ID is missing, cannot create ignore response."
             );
-            await runtime.emitEvent(EventType.RUN_ENDED, {
+            await runtime.emitEvent(EventType2.RUN_ENDED, {
               runtime,
               runId,
               messageId: message.id,
@@ -7370,7 +7628,7 @@ ${response}`
           };
           await callback(ignoreContent);
           const ignoreMemory = {
-            id: asUUID(v4_default()),
+            id: asUUID2(v4_default()),
             entityId: runtime.agentId,
             agentId: runtime.agentId,
             content: ignoreContent,
@@ -7431,7 +7689,7 @@ ${response}`
           channelType: message.content.channelType,
           roomName
         };
-        await runtime.emitEvent(EventType.RUN_ENDED, {
+        await runtime.emitEvent(EventType2.RUN_ENDED, {
           runtime,
           runId,
           messageId: message.id,
@@ -7448,7 +7706,7 @@ ${response}`
         });
       } catch (error) {
         console.error("error is", error);
-        await runtime.emitEvent(EventType.RUN_ENDED, {
+        await runtime.emitEvent(EventType2.RUN_ENDED, {
           runtime,
           runId,
           messageId: message.id,
@@ -7595,7 +7853,7 @@ var postGeneratedHandler = async ({
   let retries = 0;
   const maxRetries = 3;
   while (retries < maxRetries && (!responseContent?.thought || !responseContent?.actions)) {
-    const response = await runtime.useModel(ModelType14.TEXT_SMALL, {
+    const response = await runtime.useModel(ModelType15.TEXT_SMALL, {
       prompt
     });
     console.log("prompt is", prompt);
@@ -7627,7 +7885,7 @@ var postGeneratedHandler = async ({
     state,
     template: runtime.character.templates?.postCreationTemplate || postCreationTemplate
   });
-  const xmlResponseText = await runtime.useModel(ModelType14.TEXT_LARGE, {
+  const xmlResponseText = await runtime.useModel(ModelType15.TEXT_LARGE, {
     prompt: postPrompt
   });
   const parsedXmlResponse = parseKeyValueXml9(xmlResponseText);
@@ -7807,7 +8065,7 @@ var controlMessageHandler = async ({
   }
 };
 var events = {
-  [EventType.MESSAGE_RECEIVED]: [
+  [EventType2.MESSAGE_RECEIVED]: [
     async (payload) => {
       if (!payload.callback) {
         payload.runtime.logger.error("No callback provided for message");
@@ -7821,7 +8079,7 @@ var events = {
       });
     }
   ],
-  [EventType.VOICE_MESSAGE_RECEIVED]: [
+  [EventType2.VOICE_MESSAGE_RECEIVED]: [
     async (payload) => {
       if (!payload.callback) {
         payload.runtime.logger.error("No callback provided for voice message");
@@ -7835,7 +8093,7 @@ var events = {
       });
     }
   ],
-  [EventType.REACTION_RECEIVED]: [
+  [EventType2.REACTION_RECEIVED]: [
     async (payload) => {
       await reactionReceivedHandler({
         runtime: payload.runtime,
@@ -7843,17 +8101,17 @@ var events = {
       });
     }
   ],
-  [EventType.POST_GENERATED]: [
+  [EventType2.POST_GENERATED]: [
     async (payload) => {
       await postGeneratedHandler(payload);
     }
   ],
-  [EventType.MESSAGE_SENT]: [
+  [EventType2.MESSAGE_SENT]: [
     async (payload) => {
       payload.runtime.logger.debug(`[Bootstrap] Message sent: ${payload.message.content.text}`);
     }
   ],
-  [EventType.MESSAGE_DELETED]: [
+  [EventType2.MESSAGE_DELETED]: [
     async (payload) => {
       await messageDeletedHandler({
         runtime: payload.runtime,
@@ -7861,7 +8119,7 @@ var events = {
       });
     }
   ],
-  [EventType.CHANNEL_CLEARED]: [
+  [EventType2.CHANNEL_CLEARED]: [
     async (payload) => {
       await channelClearedHandler({
         runtime: payload.runtime,
@@ -7871,17 +8129,17 @@ var events = {
       });
     }
   ],
-  [EventType.WORLD_JOINED]: [
+  [EventType2.WORLD_JOINED]: [
     async (payload) => {
       await handleServerSync(payload);
     }
   ],
-  [EventType.WORLD_CONNECTED]: [
+  [EventType2.WORLD_CONNECTED]: [
     async (payload) => {
       await handleServerSync(payload);
     }
   ],
-  [EventType.ENTITY_JOINED]: [
+  [EventType2.ENTITY_JOINED]: [
     async (payload) => {
       payload.runtime.logger.debug(
         `[Bootstrap] ENTITY_JOINED event received for entity ${payload.entityId}`
@@ -7908,7 +8166,7 @@ var events = {
       );
     }
   ],
-  [EventType.ENTITY_LEFT]: [
+  [EventType2.ENTITY_LEFT]: [
     async (payload) => {
       try {
         const entity = await payload.runtime.getEntityById(payload.entityId);
@@ -7928,28 +8186,28 @@ var events = {
       }
     }
   ],
-  [EventType.ACTION_STARTED]: [
+  [EventType2.ACTION_STARTED]: [
     async (payload) => {
-      logger20.debug(`[Bootstrap] Action started: ${payload.actionName} (${payload.actionId})`);
+      logger21.debug(`[Bootstrap] Action started: ${payload.actionName} (${payload.actionId})`);
     }
   ],
-  [EventType.ACTION_COMPLETED]: [
+  [EventType2.ACTION_COMPLETED]: [
     async (payload) => {
       const status = payload.error ? `failed: ${payload.error.message}` : "completed";
-      logger20.debug(`[Bootstrap] Action ${status}: ${payload.actionName} (${payload.actionId})`);
+      logger21.debug(`[Bootstrap] Action ${status}: ${payload.actionName} (${payload.actionId})`);
     }
   ],
-  [EventType.EVALUATOR_STARTED]: [
+  [EventType2.EVALUATOR_STARTED]: [
     async (payload) => {
-      logger20.debug(
+      logger21.debug(
         `[Bootstrap] Evaluator started: ${payload.evaluatorName} (${payload.evaluatorId})`
       );
     }
   ],
-  [EventType.EVALUATOR_COMPLETED]: [
+  [EventType2.EVALUATOR_COMPLETED]: [
     async (payload) => {
       const status = payload.error ? `failed: ${payload.error.message}` : "completed";
-      logger20.debug(
+      logger21.debug(
         `[Bootstrap] Evaluator ${status}: ${payload.evaluatorName} (${payload.evaluatorId})`
       );
     }
@@ -7987,7 +8245,6 @@ var bootstrapPlugin = {
     factsProvider,
     roleProvider,
     settingsProvider,
-    capabilitiesProvider,
     attachmentsProvider,
     providersProvider,
     actionsProvider,
@@ -7996,7 +8253,7 @@ var bootstrapPlugin = {
     recentMessagesProvider,
     worldProvider
   ],
-  services: [TaskService]
+  services: [TaskService, EmbeddingGenerationService]
 };
 var index_default = bootstrapPlugin;
 export {