@ai.ntellect/core 0.3.0 → 0.3.3

package/dist/types.d.ts

@@ -154,8 +154,7 @@ export interface Memory {
     query: string;
     purpose: string;
     data: any;
-    scope: MemoryScopeType;
-    userId?: string;
+    roomId: string;
     createdAt: Date;
     chunks?: MemoryChunk[];
 }
@@ -205,3 +204,24 @@ export interface TransformedQueueItem {
     name: string;
     parameters: QueueItemParameter[];
 }
+export interface ScheduledAction {
+    id: string;
+    action: {
+        name: string;
+        parameters: QueueItemParameter[];
+    };
+    scheduledTime: Date;
+    userId: string;
+    status: "pending" | "completed" | "failed";
+    recurrence?: {
+        type: "daily" | "weekly" | "monthly";
+        interval: number;
+    };
+}
+export interface ScheduledActionEvents {
+    onActionStart?: (action: ScheduledAction) => void;
+    onActionComplete?: (action: ScheduledAction, result: any) => void;
+    onActionFailed?: (action: ScheduledAction, error: Error) => void;
+    onActionScheduled?: (action: ScheduledAction) => void;
+    onActionCancelled?: (actionId: string) => void;
+}

package/llm/evaluator/context.ts

@@ -1,13 +1,15 @@
 export const 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/llm/evaluator/index.ts

@@ -3,7 +3,7 @@ import { generateObject } from "ai";
 import { z } from "zod";
 import { CacheMemory } from "../../memory/cache";
 import { PersistentMemory } from "../../memory/persistent";
-import { ActionSchema, MemoryScope, MemoryType, State } from "../../types";
+import { ActionSchema, MemoryType, State } from "../../types";
 import { injectActions } from "../../utils/inject-actions";
 import { Interpreter } from "../interpreter";
 import { evaluatorContext } from "./context";
@@ -62,8 +62,8 @@ export class Evaluator {
       const response = await generateObject({
         model: this.model,
         schema: z.object({
-          actionsCompleted: z.array(z.string()),
-          actionsFailed: z.array(z.string()),
+          requestLanguage: z.string(),
+          actionsAlreadyDone: z.array(z.string()),
           extraInformationsToStore: z.array(
             z.object({
               memoryType: z.enum(["episodic", "semantic", "procedural"]),
@@ -111,7 +111,7 @@ export class Evaluator {
           console.log("Type:", item.memoryType);
           console.log("Content:", item.queryForData);
 
-          const memories = await this.memory.persistent.searchSimilarQueries(
+          const memories = await this.memory.persistent.findRelevantDocuments(
             item.queryForData,
             {
               similarityThreshold: 70,
@@ -129,7 +129,7 @@ export class Evaluator {
             purpose: item.memoryType,
             query: item.queryForData,
             data: item.data,
-            scope: MemoryScope.GLOBAL,
+            roomId: "global",
             createdAt: new Date(),
           });
         }
@@ -141,13 +141,12 @@ export class Evaluator {
         cacheMemory.createMemory({
           content: prompt,
           type: MemoryType.ACTION,
-          data: validatedResponse.actionsCompleted,
-          scope: MemoryScope.GLOBAL,
+          data: validatedResponse.actionsAlreadyDone,
         });
         console.log(
           "✅ Workflow actions completed stored in cache",
           prompt,
-          validatedResponse.actionsCompleted
+          validatedResponse.actionsAlreadyDone
         );
       }
       console.log("\n✅ Evaluation completed");
@@ -164,7 +163,7 @@ export 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(
+            const memories = await this.memory.persistent.findRelevantDocuments(
               item.content
             );
             if (memories.length === 0) {
@@ -177,7 +176,7 @@ export class Evaluator {
                 purpose: "importantToRemember",
                 query: item.content,
                 data: item.data,
-                scope: MemoryScope.USER,
+                roomId: "global",
                 createdAt: new Date(),
               });
             }

package/llm/interpreter/context.ts

@@ -1,6 +1,6 @@
 export const 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/llm/orchestrator/context.ts

@@ -1,17 +1,15 @@
 export const 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/llm/orchestrator/index.ts

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

package/memory/cache.ts

@@ -44,15 +44,8 @@ export class CacheMemory {
     }
   }
 
-  private getMemoryKey(scope: MemoryScope, userId?: string): string {
-    if (scope === MemoryScope.GLOBAL) {
-      return `${this.CACHE_PREFIX}global:`;
-    }
-    return `${this.CACHE_PREFIX}user:${userId}:`;
-  }
-
   private async storeMemory(memory: CacheMemoryType) {
-    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,
@@ -124,23 +117,10 @@ export class CacheMemory {
     scope?: MemoryScope,
     userId?: string
   ): Promise<CacheMemoryType[]> {
-    let patterns: CacheMemoryType[] = [];
-
-    if (!scope || scope === MemoryScope.GLOBAL) {
-      const globalPrefix = this.getMemoryKey(MemoryScope.GLOBAL);
-      const globalKeys = await this.redis.keys(`${globalPrefix}*`);
-      const globalPatterns = await this.getMemoriesFromKeys(globalKeys);
-      patterns = patterns.concat(globalPatterns);
-    }
-
-    if (userId && (!scope || scope === MemoryScope.USER)) {
-      const userPrefix = this.getMemoryKey(MemoryScope.USER, userId);
-      const userKeys = await this.redis.keys(`${userPrefix}*`);
-      const userPatterns = await this.getMemoriesFromKeys(userKeys);
-      patterns = patterns.concat(userPatterns);
-    }
+    const keys = await this.redis.keys(`${this.CACHE_PREFIX}*`);
+    const memories = await this.getMemoriesFromKeys(keys);
 
-    return patterns;
+    return memories;
   }
 
   private async getMemoriesFromKeys(

package/memory/persistent.ts

@@ -28,18 +28,6 @@ interface MeilisearchResponse {
   }>;
 }
 
-interface SearchParams {
-  q?: string;
-  offset?: number;
-  limit?: number;
-  filter?: string | string[];
-  facets?: string[];
-  attributesToRetrieve?: string[];
-  attributesToSearchOn?: string[];
-  sort?: string[];
-  matchingStrategy?: "last" | "all" | "frequency";
-}
-
 interface ProcessedChunk {
   content: string;
   embedding: number[];
@@ -56,7 +44,7 @@ export class PersistentMemory {
   constructor(options: { host: string; apiKey: string; indexPrefix?: string }) {
     this.host = options.host;
     this.apiKey = options.apiKey;
-    this.INDEX_PREFIX = options.indexPrefix || "memory_";
+    this.INDEX_PREFIX = options.indexPrefix || "memory";
   }
 
   /**
@@ -64,10 +52,7 @@ export class PersistentMemory {
    */
   async init() {
     // Create global index
-    await this._getOrCreateIndex(this._getIndexName(MemoryScope.GLOBAL));
-
-    // Create user index
-    await this._getOrCreateIndex(this._getIndexName(MemoryScope.USER));
+    await this._getOrCreateIndex(this.INDEX_PREFIX);
   }
 
   /**
@@ -94,17 +79,6 @@ export class PersistentMemory {
 
     return response.json() as Promise<T>;
   }
-
-  /**
-   * Get index name based on scope and userId
-   */
-  private _getIndexName(scope: MemoryScope, userId?: string): string {
-    if (scope === "global") {
-      return `${this.INDEX_PREFIX}global`;
-    }
-    return `${this.INDEX_PREFIX}user_${userId}`;
-  }
-
   /**
    * Get or create an index with proper settings
    */
@@ -161,8 +135,7 @@ export class PersistentMemory {
    * Store a memory in the database
    */
   async createMemory(memory: 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);
 
@@ -173,7 +146,7 @@ export class PersistentMemory {
     };
 
     const response = await this._makeRequest(
-      `/indexes/${indexName}/documents`,
+      `/indexes/${this.INDEX_PREFIX}/documents`,
       {
         method: "POST",
         body: JSON.stringify([document]),
@@ -186,7 +159,7 @@ export class PersistentMemory {
   /**
    * Find best matching memories
    */
-  async searchSimilarQueries(query: string, options: SearchOptions = {}) {
+  async findRelevantDocuments(query: string, options: SearchOptions = {}) {
     console.log("\n🔍 Searching in persistent memory");
     console.log("Query:", query);
     console.log("Options:", JSON.stringify(options, null, 2));
@@ -199,42 +172,20 @@ export class PersistentMemory {
 
     const searchResults = [];
 
-    // Search in global memories
-    if (!options.scope || options.scope === "global") {
-      const globalIndex = this._getIndexName(MemoryScope.GLOBAL);
-      console.log("\n📚 Searching in global index:", globalIndex);
-      try {
-        const globalResults = await this._makeRequest<MeilisearchResponse>(
-          `/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 === MemoryScope.USER)
-    ) {
-      const userIndex = this._getIndexName(MemoryScope.USER, options.userId);
-      const userResults = await this._makeRequest<MeilisearchResponse>(
-        `/indexes/${userIndex}/search`,
+    console.log("\n📚 Searching in global index:", this.INDEX_PREFIX);
+    try {
+      const globalResults = await this._makeRequest<MeilisearchResponse>(
+        `/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;
@@ -244,13 +195,11 @@ export class PersistentMemory {
     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:
             (cosineSimilarity(queryEmbedding, chunk.embedding) + 1) * 50,
+          createdAt: hit.createdAt,
         }));
 
         return chunkSimilarities.reduce(
@@ -275,10 +224,6 @@ export 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 {
       console.log("\n❌ No relevant matches found");
@@ -290,9 +235,8 @@ export class PersistentMemory {
   /**
    * Delete memories for a given scope and user
    */
-  async deleteMemories(scope: MemoryScope, userId?: string) {
-    const indexName = this._getIndexName(scope, userId);
-    return this._makeRequest(`/indexes/${indexName}`, {
+  async deleteMemories() {
+    return this._makeRequest(`/indexes/${this.INDEX_PREFIX}`, {
       method: "DELETE",
     });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai.ntellect/core",
-  "version": "0.3.0",
+  "version": "0.3.3",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/services/scheduler.ts

@@ -0,0 +1,167 @@
+import { Orchestrator } from "../llm/orchestrator";
+import { ActionSchema, ScheduledAction, ScheduledActionEvents } from "../types";
+import { ActionQueueManager } from "./queue";
+
+export class ActionScheduler {
+  private scheduledActions: Map<string, NodeJS.Timeout> = new Map();
+  private storage: ScheduledActionStorage;
+  private events: ScheduledActionEvents;
+
+  constructor(
+    private actionQueueManager: ActionQueueManager,
+    private orchestrator: Orchestrator,
+    events: ScheduledActionEvents = {}
+  ) {
+    this.storage = new ScheduledActionStorage();
+    this.events = events;
+    this.initializeScheduledActions();
+  }
+
+  async scheduleAction(
+    action: ActionSchema,
+    scheduledTime: Date,
+    userId: string,
+    recurrence?: ScheduledAction["recurrence"]
+  ): Promise<string> {
+    const scheduledAction: ScheduledAction = {
+      id: crypto.randomUUID(),
+      action: {
+        name: action.name,
+        parameters: [],
+      },
+      scheduledTime,
+      userId,
+      status: "pending",
+      recurrence,
+    };
+
+    await this.storage.saveScheduledAction(scheduledAction);
+    this.scheduleExecution(scheduledAction);
+    this.events.onActionScheduled?.(scheduledAction);
+
+    return scheduledAction.id;
+  }
+
+  private async initializeScheduledActions() {
+    const pendingActions = await this.storage.getPendingActions();
+    pendingActions.forEach((action) => this.scheduleExecution(action));
+  }
+
+  private scheduleExecution(scheduledAction: ScheduledAction) {
+    const now = new Date();
+    const delay = scheduledAction.scheduledTime.getTime() - now.getTime();
+
+    if (delay < 0) return;
+
+    const timeout = setTimeout(async () => {
+      try {
+        await this.executeScheduledAction(scheduledAction);
+
+        if (scheduledAction.recurrence) {
+          const nextExecutionTime = this.calculateNextExecutionTime(
+            scheduledAction.scheduledTime,
+            scheduledAction.recurrence
+          );
+          const actionSchema = this.orchestrator.tools.find(
+            (tool: ActionSchema) => tool.name === scheduledAction.action.name
+          );
+          if (actionSchema) {
+            await this.scheduleAction(
+              actionSchema,
+              nextExecutionTime,
+              scheduledAction.userId,
+              scheduledAction.recurrence
+            );
+          }
+        }
+      } catch (error) {
+        console.error(
+          `Failed to execute scheduled action ${scheduledAction.id}:`,
+          error
+        );
+        await this.storage.updateActionStatus(scheduledAction.id, "failed");
+      }
+    }, delay);
+
+    this.scheduledActions.set(scheduledAction.id, timeout);
+  }
+
+  private async executeScheduledAction(scheduledAction: ScheduledAction) {
+    try {
+      this.events.onActionStart?.(scheduledAction);
+
+      this.actionQueueManager.addToQueue({
+        name: scheduledAction.action.name,
+        parameters: scheduledAction.action.parameters,
+      });
+
+      const result = await this.actionQueueManager.processQueue();
+      await this.storage.updateActionStatus(scheduledAction.id, "completed");
+
+      this.events.onActionComplete?.(scheduledAction, result);
+    } catch (error) {
+      await this.storage.updateActionStatus(scheduledAction.id, "failed");
+      this.events.onActionFailed?.(scheduledAction, error as Error);
+      throw error;
+    }
+  }
+
+  private calculateNextExecutionTime(
+    currentTime: Date,
+    recurrence: NonNullable<ScheduledAction["recurrence"]>
+  ): Date {
+    const nextTime = new Date(currentTime);
+
+    switch (recurrence.type) {
+      case "daily":
+        nextTime.setDate(nextTime.getDate() + recurrence.interval);
+        break;
+      case "weekly":
+        nextTime.setDate(nextTime.getDate() + 7 * recurrence.interval);
+        break;
+      case "monthly":
+        nextTime.setMonth(nextTime.getMonth() + recurrence.interval);
+        break;
+    }
+
+    return nextTime;
+  }
+
+  async cancelScheduledAction(actionId: string): Promise<boolean> {
+    const timeout = this.scheduledActions.get(actionId);
+    if (timeout) {
+      clearTimeout(timeout);
+      this.scheduledActions.delete(actionId);
+      await this.storage.deleteScheduledAction(actionId);
+      this.events.onActionCancelled?.(actionId);
+      return true;
+    }
+    return false;
+  }
+}
+
+class ScheduledActionStorage {
+  private actions: ScheduledAction[] = [];
+
+  async saveScheduledAction(action: ScheduledAction): Promise<void> {
+    this.actions.push(action);
+  }
+
+  async getPendingActions(): Promise<ScheduledAction[]> {
+    return this.actions.filter((action) => action.status === "pending");
+  }
+
+  async updateActionStatus(
+    actionId: string,
+    status: ScheduledAction["status"]
+  ): Promise<void> {
+    const action = this.actions.find((a) => a.id === actionId);
+    if (action) {
+      action.status = status;
+    }
+  }
+
+  async deleteScheduledAction(actionId: string): Promise<void> {
+    this.actions = this.actions.filter((a) => a.id !== actionId);
+  }
+}