@ai.ntellect/core 0.3.1 → 0.3.3

package/agent/index.ts

@@ -3,7 +3,15 @@ import { Interpreter } from "../llm/interpreter";
 import { Orchestrator } from "../llm/orchestrator";
 import { CacheMemory } from "../memory/cache";
 import { PersistentMemory } from "../memory/persistent";
-import { ActionSchema, AgentEvent, MemoryScope, QueueResult } from "../types";
+import { ActionQueueManager } from "../services/queue";
+import { ActionScheduler } from "../services/scheduler";
+import {
+  ActionSchema,
+  AgentEvent,
+  MemoryScope,
+  QueueResult,
+  ScheduledAction,
+} from "../types";
 import { QueueItemTransformer } from "../utils/queue-item-transformer";
 import { ResultSanitizer } from "../utils/sanitize-results";
 import { ActionHandler } from "./handlers/ActionHandler";
@@ -21,6 +29,7 @@ export class Agent {
   private evaluatorIteration = 0;
   private accumulatedResults: string = "";
   private currentInterpreter: Interpreter | undefined;
+  private readonly scheduler: ActionScheduler;
 
   constructor({
     orchestrator,
@@ -45,18 +54,27 @@ export class Agent {
     this.maxEvaluatorIteration = maxEvaluatorIteration;
     this.actionHandler = new ActionHandler();
     this.accumulatedResults = "";
+    this.scheduler = new ActionScheduler(
+      new ActionQueueManager(this.orchestrator.tools),
+      this.orchestrator
+    );
   }
 
   async process(prompt: string, events: AgentEvent): Promise<any> {
     this.accumulatedResults = "";
     this.evaluatorIteration = 0;
     console.log("Requesting orchestrator for actions..");
-    const cacheMemories = await this.memory.cache?.findSimilarActions(prompt, {
-      similarityThreshold: 70,
-      maxResults: 5,
-      userId: "1",
-      scope: MemoryScope.GLOBAL,
-    });
+    const parsedPrompt = JSON.parse(prompt);
+    const promptOnly = parsedPrompt.userRequest;
+    const cacheMemories = await this.memory.cache?.findSimilarActions(
+      promptOnly,
+      {
+        similarityThreshold: 70,
+        maxResults: 5,
+        userId: "1",
+        scope: MemoryScope.GLOBAL,
+      }
+    );
     console.log("✅ RECENT_ACTIONS: ", cacheMemories);
 
     const persistentMemory = await this.memory.persistent.findRelevantDocuments(
@@ -221,4 +239,22 @@ export class Agent {
     const sanitizedResults = ResultSanitizer.sanitize(formattedResults);
     return sanitizedResults;
   }
+
+  async scheduleAction(
+    action: ActionSchema,
+    scheduledTime: Date,
+    userId: string,
+    recurrence?: ScheduledAction["recurrence"]
+  ): Promise<string> {
+    return this.scheduler.scheduleAction(
+      action,
+      scheduledTime,
+      userId,
+      recurrence
+    );
+  }
+
+  async cancelScheduledAction(actionId: string): Promise<boolean> {
+    return this.scheduler.cancelScheduledAction(actionId);
+  }
 }

package/dist/agent/index.d.ts

@@ -2,7 +2,7 @@ import { Interpreter } from "../llm/interpreter";
 import { Orchestrator } from "../llm/orchestrator";
 import { CacheMemory } from "../memory/cache";
 import { PersistentMemory } from "../memory/persistent";
-import { AgentEvent } from "../types";
+import { ActionSchema, AgentEvent, ScheduledAction } from "../types";
 export declare class Agent {
     private readonly actionHandler;
     private readonly orchestrator;
@@ -12,6 +12,8 @@ export declare class Agent {
     private readonly maxEvaluatorIteration;
     private evaluatorIteration;
     private accumulatedResults;
+    private currentInterpreter;
+    private readonly scheduler;
     constructor({ orchestrator, interpreters, memory, stream, maxEvaluatorIteration, }: {
         orchestrator: Orchestrator;
         interpreters: Interpreter[];
@@ -28,4 +30,6 @@ export declare class Agent {
     private interpreterResult;
     private transformActions;
     private formatResults;
+    scheduleAction(action: ActionSchema, scheduledTime: Date, userId: string, recurrence?: ScheduledAction["recurrence"]): Promise<string>;
+    cancelScheduledAction(actionId: string): Promise<boolean>;
 }

package/dist/agent/index.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Agent = void 0;
 const evaluator_1 = require("../llm/evaluator");
+const queue_1 = require("../services/queue");
+const scheduler_1 = require("../services/scheduler");
 const types_1 = require("../types");
 const queue_item_transformer_1 = require("../utils/queue-item-transformer");
 const sanitize_results_1 = require("../utils/sanitize-results");
@@ -17,19 +19,26 @@ class Agent {
         this.maxEvaluatorIteration = maxEvaluatorIteration;
         this.actionHandler = new ActionHandler_1.ActionHandler();
         this.accumulatedResults = "";
+        this.scheduler = new scheduler_1.ActionScheduler(new queue_1.ActionQueueManager(this.orchestrator.tools), this.orchestrator);
     }
     async process(prompt, events) {
         this.accumulatedResults = "";
         this.evaluatorIteration = 0;
         console.log("Requesting orchestrator for actions..");
-        const cacheMemories = await this.memory.cache?.findSimilarActions(prompt, {
+        const parsedPrompt = JSON.parse(prompt);
+        const promptOnly = parsedPrompt.userRequest;
+        const cacheMemories = await this.memory.cache?.findSimilarActions(promptOnly, {
             similarityThreshold: 70,
             maxResults: 5,
             userId: "1",
             scope: types_1.MemoryScope.GLOBAL,
         });
         console.log("✅ RECENT_ACTIONS: ", cacheMemories);
-        const request = await this.orchestrator.process(prompt, `## RECENT_ACTIONS: ${JSON.stringify(cacheMemories)} ## CURRENT_RESULTS: ${this.accumulatedResults}`);
+        const persistentMemory = await this.memory.persistent.findRelevantDocuments(prompt, {
+            similarityThreshold: 80,
+        });
+        console.log("✅ PERSISTENT_MEMORY: ", persistentMemory);
+        const request = await this.orchestrator.process(prompt, `## RECENT_ACTIONS: ${JSON.stringify(cacheMemories)} ## PERSISTENT_MEMORY: ${JSON.stringify(persistentMemory)} ## CURRENT_RESULTS: ${this.accumulatedResults}`);
         events.onMessage?.(request);
         return request.actions.length > 0
             ? this.handleActions({
@@ -59,12 +68,12 @@ class Agent {
             return this.interpreterResult({
                 data: this.accumulatedResults,
                 initialPrompt,
-                interpreter: this.interpreters[0],
+                interpreter: this.currentInterpreter,
             });
         }
         const evaluator = new evaluator_1.Evaluator(this.orchestrator.tools, this.memory, this.interpreters);
-        // const sanitizedResults = ResultSanitizer.sanitize(this.accumulatedResults);
         const evaluation = await evaluator.process(initialPrompt, this.accumulatedResults);
+        this.currentInterpreter = this.getInterpreter(this.interpreters, evaluation.interpreter);
         events.onMessage?.(evaluation);
         if (evaluation.isNextActionNeeded) {
             this.evaluatorIteration++;
@@ -73,21 +82,22 @@ class Agent {
                 actions: evaluation.nextActionsNeeded,
             }, events);
         }
-        const interpreter = this.getInterpreter(this.interpreters, evaluation.interpreter);
-        if (!interpreter) {
-            throw new Error("Interpreter not found");
-        }
         return this.interpreterResult({
             data: this.accumulatedResults,
             initialPrompt,
-            interpreter,
+            interpreter: this.currentInterpreter,
         });
     }
     getInterpreter(interpreters, name) {
+        console.log({ interpreters, name });
         return interpreters.find((interpreter) => interpreter.name === name);
     }
     async interpreterResult(actionsResult) {
         const { interpreter, initialPrompt, data } = actionsResult;
+        if (!interpreter) {
+            throw new Error("Interpreter not found");
+        }
+        console.log("✅ INTERPRETER: ", interpreter.name);
         return this.stream
             ? (await interpreter.streamProcess(initialPrompt, {
                 userRequest: initialPrompt,
@@ -112,5 +122,11 @@ class Agent {
         const sanitizedResults = sanitize_results_1.ResultSanitizer.sanitize(formattedResults);
         return sanitizedResults;
     }
+    async scheduleAction(action, scheduledTime, userId, recurrence) {
+        return this.scheduler.scheduleAction(action, scheduledTime, userId, recurrence);
+    }
+    async cancelScheduledAction(actionId) {
+        return this.scheduler.cancelScheduledAction(actionId);
+    }
 }
 exports.Agent = Agent;

package/dist/llm/evaluator/context.js

@@ -3,14 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.evaluatorContext = void 0;
 exports.evaluatorContext = {
     behavior: {
-        language: "user_language",
-        role: "Your role is to verify if the goal has been achieved and make a response or suggest next actions.",
+        language: "same_as_user",
+        role: "Your role is to ensure the goal will be achieved and make a response or suggest next actions.",
         guidelines: {
             important: [
-                "Verify if all required actions were executed successfully.",
-                "Check if the results align with the initial goal.",
+                "Verify if all actions were executed successfully (actionsAlreadyDone).",
+                "Check if the results align with the initial goal (explain in 'why' field).",
+                "Suggest next actions in 'nextActionsNeeded' if the goal is not achieved and if actions in 'actionsAlreadyDone' are not enough.",
                 "If you retrieved the informations from your internal knowledge base, no need to store them in 'extraInformationsToStore'.",
-                "Store ONLY extra new needed informations in 'extraInformationsToStore' (choose the most relevant informations and memory type: episodic, semantic, or procedural).",
+                "Store ONLY new needed informations in 'extraInformationsToStore'.",
+                "Choose the most relevant informations and memory type: episodic, semantic, or procedural.",
             ],
             warnings: [
                 "NEVER store an old data you retrieve from your internal knowledge base.",

package/dist/llm/evaluator/index.js

@@ -43,8 +43,8 @@ class Evaluator {
             const response = await (0, ai_1.generateObject)({
                 model: this.model,
                 schema: zod_1.z.object({
-                    actionsCompleted: zod_1.z.array(zod_1.z.string()),
-                    actionsFailed: zod_1.z.array(zod_1.z.string()),
+                    requestLanguage: zod_1.z.string(),
+                    actionsAlreadyDone: zod_1.z.array(zod_1.z.string()),
                     extraInformationsToStore: zod_1.z.array(zod_1.z.object({
                         memoryType: zod_1.z.enum(["episodic", "semantic", "procedural"]),
                         queryForData: zod_1.z.string(),
@@ -80,7 +80,7 @@ class Evaluator {
                     console.log("\n📝 Processing memory item:");
                     console.log("Type:", item.memoryType);
                     console.log("Content:", item.queryForData);
-                    const memories = await this.memory.persistent.searchSimilarQueries(item.queryForData, {
+                    const memories = await this.memory.persistent.findRelevantDocuments(item.queryForData, {
                         similarityThreshold: 70,
                     });
                     if (memories.length > 0) {
@@ -93,7 +93,7 @@ class Evaluator {
                         purpose: item.memoryType,
                         query: item.queryForData,
                         data: item.data,
-                        scope: types_1.MemoryScope.GLOBAL,
+                        roomId: "global",
                         createdAt: new Date(),
                     });
                 }
@@ -104,10 +104,9 @@ class Evaluator {
                 cacheMemory.createMemory({
                     content: prompt,
                     type: types_1.MemoryType.ACTION,
-                    data: validatedResponse.actionsCompleted,
-                    scope: types_1.MemoryScope.GLOBAL,
+                    data: validatedResponse.actionsAlreadyDone,
                 });
-                console.log("✅ Workflow actions completed stored in cache", prompt, validatedResponse.actionsCompleted);
+                console.log("✅ Workflow actions completed stored in cache", prompt, validatedResponse.actionsAlreadyDone);
             }
             console.log("\n✅ Evaluation completed");
             console.log("─".repeat(50));
@@ -123,7 +122,7 @@ class Evaluator {
                 if (error.value.extraInformationsToStore.length > 0) {
                     for (const item of error.value.extraInformationsToStore) {
                         // Check if the item is already in the memory
-                        const memories = await this.memory.persistent.searchSimilarQueries(item.content);
+                        const memories = await this.memory.persistent.findRelevantDocuments(item.content);
                         if (memories.length === 0) {
                             console.log("Adding to memory", {
                                 query: item.content,
@@ -134,7 +133,7 @@ class Evaluator {
                                 purpose: "importantToRemember",
                                 query: item.content,
                                 data: item.data,
-                                scope: types_1.MemoryScope.USER,
+                                roomId: "global",
                                 createdAt: new Date(),
                             });
                         }

package/dist/llm/interpreter/context.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.marketInterpreterContext = exports.securityInterpreterContext = exports.generalInterpreterContext = void 0;
 exports.generalInterpreterContext = {
     role: "You are the general assistant. Your role is to provide a clear and factual analysis of the results.",
-    language: "user_language",
+    language: "same_as_user",
     guidelines: {
         important: [],
         warnings: [],

package/dist/llm/orchestrator/context.d.ts

@@ -4,7 +4,7 @@ export declare const orchestratorContext: {
         role: string;
         guidelines: {
             important: string[];
-            warnings: never[];
+            warnings: string[];
         };
     };
 };

package/dist/llm/orchestrator/context.js

@@ -3,18 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.orchestratorContext = void 0;
 exports.orchestratorContext = {
     behavior: {
-        language: "user_language",
-        role: "You are the orchestrator agent. Your role is to determine what actions are needed to achieve the user goal.",
+        language: "same_as_user",
+        role: "Your role is to determine what actions are needed to achieve the user goal.",
         guidelines: {
             important: [
                 "If there is no action to do, you must answer in the 'answer' field.",
                 "If some parameters are not clear or missing, don't add the action, YOU MUST ask the user for them.",
-                "ALWAYS use the same language as user request. (If it's English, use English, if it's French, use French, etc.)",
+                "For QUESTIONS or ANALYSIS, search first in your internal knowledge base before using actions.",
                 "For ON-CHAIN actions, just use the useful actions.",
-                "For QUESTIONS or ANALYSIS, you MUST search in your cache memory or/and internal knowledge base.",
-                "NEVER repeat same actions if the user doesn't ask for it.",
             ],
-            warnings: [],
+            warnings: ["NEVER repeat same actions if the user doesn't ask for it."],
         },
     },
 };

package/dist/llm/orchestrator/index.js

@@ -20,7 +20,7 @@ class Orchestrator {
                     query: zod_1.z.string(),
                 }),
                 execute: async ({ query }) => {
-                    const persistentMemories = await this.memory.persistent.searchSimilarQueries(query, {
+                    const persistentMemories = await this.memory.persistent.findRelevantDocuments(query, {
                         similarityThreshold: 70,
                     });
                     return `# LONG_TERM_MEMORY: ${JSON.stringify(persistentMemories)}`;

package/dist/memory/cache.d.ts

@@ -5,7 +5,6 @@ export declare class CacheMemory {
     private readonly CACHE_TTL;
     constructor(options?: CacheMemoryOptions);
     private initRedis;
-    private getMemoryKey;
     private storeMemory;
     findSimilarActions(query: string, options?: MatchOptions & {
         userId?: string;

package/dist/memory/cache.js

@@ -31,14 +31,8 @@ class CacheMemory {
             console.error("❌ Failed to connect to Redis:", error);
         }
     }
-    getMemoryKey(scope, userId) {
-        if (scope === types_1.MemoryScope.GLOBAL) {
-            return `${this.CACHE_PREFIX}global:`;
-        }
-        return `${this.CACHE_PREFIX}user:${userId}:`;
-    }
     async storeMemory(memory) {
-        const prefix = this.getMemoryKey(memory.scope, memory.userId);
+        const prefix = this.CACHE_PREFIX;
         const key = `${prefix}${memory.id}`;
         const result = await this.redis.set(key, JSON.stringify(memory), {
             EX: this.CACHE_TTL,
@@ -87,20 +81,9 @@ class CacheMemory {
         return results;
     }
     async getAllMemories(scope, userId) {
-        let patterns = [];
-        if (!scope || scope === types_1.MemoryScope.GLOBAL) {
-            const globalPrefix = this.getMemoryKey(types_1.MemoryScope.GLOBAL);
-            const globalKeys = await this.redis.keys(`${globalPrefix}*`);
-            const globalPatterns = await this.getMemoriesFromKeys(globalKeys);
-            patterns = patterns.concat(globalPatterns);
-        }
-        if (userId && (!scope || scope === types_1.MemoryScope.USER)) {
-            const userPrefix = this.getMemoryKey(types_1.MemoryScope.USER, userId);
-            const userKeys = await this.redis.keys(`${userPrefix}*`);
-            const userPatterns = await this.getMemoriesFromKeys(userKeys);
-            patterns = patterns.concat(userPatterns);
-        }
-        return patterns;
+        const keys = await this.redis.keys(`${this.CACHE_PREFIX}*`);
+        const memories = await this.getMemoriesFromKeys(keys);
+        return memories;
     }
     async getMemoriesFromKeys(keys) {
         const memories = [];

package/dist/memory/persistent.d.ts

@@ -29,10 +29,6 @@ export declare class PersistentMemory {
      * Make API request to Meilisearch
      */
     private _makeRequest;
-    /**
-     * Get index name based on scope and userId
-     */
-    private _getIndexName;
     /**
      * Get or create an index with proper settings
      */
@@ -45,17 +41,15 @@ export declare class PersistentMemory {
     /**
      * Find best matching memories
      */
-    searchSimilarQueries(query: string, options?: SearchOptions): Promise<{
-        createdAt: string;
-        data: any;
-        purpose: string;
+    findRelevantDocuments(query: string, options?: SearchOptions): Promise<{
         query: string;
-        chunk: string;
+        data: any;
         similarityPercentage: number;
+        createdAt: string;
     }[]>;
     /**
      * Delete memories for a given scope and user
      */
-    deleteMemories(scope: MemoryScope, userId?: string): Promise<unknown>;
+    deleteMemories(): Promise<unknown>;
 }
 export {};

package/dist/memory/persistent.js

@@ -4,7 +4,6 @@ exports.PersistentMemory = void 0;
 const openai_1 = require("@ai-sdk/openai");
 const ai_1 = require("ai");
 const text_splitter_1 = require("langchain/text_splitter");
-const types_1 = require("../types");
 /**
  * Handles persistent memory storage using Meilisearch API
  */
@@ -12,16 +11,14 @@ class PersistentMemory {
     constructor(options) {
         this.host = options.host;
         this.apiKey = options.apiKey;
-        this.INDEX_PREFIX = options.indexPrefix || "memory_";
+        this.INDEX_PREFIX = options.indexPrefix || "memory";
     }
     /**
      * Initialize indexes
      */
     async init() {
         // Create global index
-        await this._getOrCreateIndex(this._getIndexName(types_1.MemoryScope.GLOBAL));
-        // Create user index
-        await this._getOrCreateIndex(this._getIndexName(types_1.MemoryScope.USER));
+        await this._getOrCreateIndex(this.INDEX_PREFIX);
     }
     /**
      * Make API request to Meilisearch
@@ -42,15 +39,6 @@ class PersistentMemory {
         }
         return response.json();
     }
-    /**
-     * Get index name based on scope and userId
-     */
-    _getIndexName(scope, userId) {
-        if (scope === "global") {
-            return `${this.INDEX_PREFIX}global`;
-        }
-        return `${this.INDEX_PREFIX}user_${userId}`;
-    }
     /**
      * Get or create an index with proper settings
      */
@@ -102,15 +90,14 @@ class PersistentMemory {
      * Store a memory in the database
      */
     async createMemory(memory) {
-        const indexName = this._getIndexName(memory.scope, memory.userId);
-        await this._getOrCreateIndex(indexName);
+        await this._getOrCreateIndex(memory.roomId);
         const chunks = await this.processContent(memory.data);
         const document = {
             ...memory,
             chunks,
             createdAt: memory.createdAt.toISOString(),
         };
-        const response = await this._makeRequest(`/indexes/${indexName}/documents`, {
+        const response = await this._makeRequest(`/indexes/${this.INDEX_PREFIX}/documents`, {
             method: "POST",
             body: JSON.stringify([document]),
         });
@@ -120,7 +107,7 @@ class PersistentMemory {
     /**
      * Find best matching memories
      */
-    async searchSimilarQueries(query, options = {}) {
+    async findRelevantDocuments(query, options = {}) {
         console.log("\n🔍 Searching in persistent memory");
         console.log("Query:", query);
         console.log("Options:", JSON.stringify(options, null, 2));
@@ -130,47 +117,29 @@ class PersistentMemory {
             value: query,
         });
         const searchResults = [];
-        // Search in global memories
-        if (!options.scope || options.scope === "global") {
-            const globalIndex = this._getIndexName(types_1.MemoryScope.GLOBAL);
-            console.log("\n📚 Searching in global index:", globalIndex);
-            try {
-                const globalResults = await this._makeRequest(`/indexes/${globalIndex}/search`, {
-                    method: "POST",
-                    body: JSON.stringify({ q: query }),
-                });
-                if (globalResults?.hits) {
-                    searchResults.push(...globalResults.hits);
-                }
-            }
-            catch (error) {
-                console.error("❌ Error searching global index:", error);
-            }
-        }
-        // Search in user memories
-        if (options.userId &&
-            (!options.scope || options.scope === types_1.MemoryScope.USER)) {
-            const userIndex = this._getIndexName(types_1.MemoryScope.USER, options.userId);
-            const userResults = await this._makeRequest(`/indexes/${userIndex}/search`, {
+        console.log("\n📚 Searching in global index:", this.INDEX_PREFIX);
+        try {
+            const globalResults = await this._makeRequest(`/indexes/${this.INDEX_PREFIX}/search`, {
                 method: "POST",
                 body: JSON.stringify({ q: query }),
             });
-            if (userResults.hits) {
-                searchResults.push(...userResults.hits);
+            if (globalResults?.hits) {
+                searchResults.push(...globalResults.hits);
             }
         }
+        catch (error) {
+            console.error("❌ Error searching global index:", error);
+        }
         const totalResults = searchResults.length;
         console.log(`\n📊 Found ${totalResults} total matches`);
         // Process and filter results using cosine similarity
         const results = searchResults
             .flatMap((hit) => {
             const chunkSimilarities = hit.chunks.map((chunk) => ({
-                createdAt: hit.createdAt,
-                data: hit.data,
-                purpose: hit.purpose,
                 query: hit.query,
-                chunk: chunk.content,
+                data: hit.data,
                 similarityPercentage: ((0, ai_1.cosineSimilarity)(queryEmbedding, chunk.embedding) + 1) * 50,
+                createdAt: hit.createdAt,
             }));
             return chunkSimilarities.reduce((best, current) => current.similarityPercentage > best.similarityPercentage
                 ? current
@@ -185,10 +154,6 @@ class PersistentMemory {
             results.forEach((match, index) => {
                 console.log(`\n${index + 1}. Match Details:`);
                 console.log(`   Query: ${match.query}`);
-                console.log(`   Purpose: ${match.purpose}`);
-                console.log(`   Similarity: ${match.similarityPercentage.toFixed(2)}%`);
-                console.log(`   Content: "${match.chunk}"`);
-                console.log("─".repeat(50));
             });
         }
         else {
@@ -199,9 +164,8 @@ class PersistentMemory {
     /**
      * Delete memories for a given scope and user
      */
-    async deleteMemories(scope, userId) {
-        const indexName = this._getIndexName(scope, userId);
-        return this._makeRequest(`/indexes/${indexName}`, {
+    async deleteMemories() {
+        return this._makeRequest(`/indexes/${this.INDEX_PREFIX}`, {
             method: "DELETE",
         });
     }

package/dist/services/scheduler.d.ts

@@ -0,0 +1,17 @@
+import { Orchestrator } from "../llm/orchestrator";
+import { ActionSchema, ScheduledAction, ScheduledActionEvents } from "../types";
+import { ActionQueueManager } from "./queue";
+export declare class ActionScheduler {
+    private actionQueueManager;
+    private orchestrator;
+    private scheduledActions;
+    private storage;
+    private events;
+    constructor(actionQueueManager: ActionQueueManager, orchestrator: Orchestrator, events?: ScheduledActionEvents);
+    scheduleAction(action: ActionSchema, scheduledTime: Date, userId: string, recurrence?: ScheduledAction["recurrence"]): Promise<string>;
+    private initializeScheduledActions;
+    private scheduleExecution;
+    private executeScheduledAction;
+    private calculateNextExecutionTime;
+    cancelScheduledAction(actionId: string): Promise<boolean>;
+}