@ai.ntellect/core 0.6.17 → 0.6.19

package/test/memory/base.test.ts

@@ -1,225 +0,0 @@
-import { BaseMemoryService } from "../../interfaces";
-import { BaseMemory } from "../../memory";
-import { BaseMemoryType, CreateMemoryInput } from "../../types";
-import { expect } from "chai";
-
-/**
- * Test suite for the BaseMemory service
- * This suite tests the memory management system that handles storage and retrieval of memory entries
- */
-
-// Classe concrète pour tester BaseMemory
-class TestMemory extends BaseMemory {
-  async init(): Promise<void> {
-    await this.cacheService.initializeConnection();
-  }
-
-  async createMemory(
-    input: CreateMemoryInput & { embedding?: number[] }
-  ): Promise<BaseMemoryType | undefined> {
-    const memory: BaseMemoryType = {
-      id: crypto.randomUUID(),
-      data: input.data,
-      embedding: input.embedding || null,
-      roomId: input.roomId,
-      createdAt: new Date(),
-    };
-    await this.cacheService.createMemory(memory, input.ttl);
-    return memory;
-  }
-
-  async getMemoryById(
-    id: string,
-    roomId: string
-  ): Promise<BaseMemoryType | null> {
-    return this.cacheService.getMemoryById(id);
-  }
-
-  async getMemoryByIndex(
-    query: string,
-    options: { roomId: string; limit?: number }
-  ): Promise<BaseMemoryType[]> {
-    return this.cacheService.getMemoryByIndex(query, options);
-  }
-
-  async getAllMemories(roomId: string): Promise<BaseMemoryType[]> {
-    return this.cacheService.getAllMemories();
-  }
-
-  async clearMemoryById(id: string, roomId: string): Promise<void> {
-    await this.cacheService.clearMemoryById(id);
-  }
-
-  async clearAllMemories(): Promise<void> {
-    await this.cacheService.clearAllMemories();
-  }
-}
-
-describe("BaseMemory", () => {
-  let memory: TestMemory;
-  let mockMemoryService: BaseMemoryService;
-  const TEST_ROOM_ID = "test-room";
-
-  // Mock data for testing
-  const testMemory: BaseMemoryType = {
-    id: "test-id",
-    data: "test data",
-    embedding: [0.1, 0.2, 0.3],
-    roomId: "test-room",
-    createdAt: new Date(),
-  };
-
-  beforeEach(() => {
-    // Create mock implementation of BaseMemoryService
-    mockMemoryService = {
-      initializeConnection: async () => Promise.resolve(),
-      createMemory: async (memory: BaseMemoryType) => Promise.resolve(),
-      getMemoryById: async (id: string) => Promise.resolve(testMemory),
-      getMemoryByIndex: async (query: string, options: any) =>
-        Promise.resolve([testMemory]),
-      getAllMemories: async () => Promise.resolve([testMemory]),
-      clearMemoryById: async (id: string) => Promise.resolve(),
-      clearAllMemories: async () => Promise.resolve(),
-    };
-
-    memory = new TestMemory(mockMemoryService);
-  });
-
-  describe("Initialization", () => {
-    it("should initialize the memory service", async () => {
-      let initCalled = false;
-      mockMemoryService.initializeConnection = async () => {
-        initCalled = true;
-      };
-
-      await memory.init();
-      expect(initCalled).to.be.true;
-    });
-  });
-
-  describe("Memory Creation", () => {
-    it("should create a new memory entry", async () => {
-      const input = {
-        data: "test data",
-        query: "test query",
-        roomId: "test-room",
-        ttl: 3600,
-      };
-
-      const result = await memory.createMemory(input);
-
-      expect(result).to.exist;
-      expect(result?.data).to.equal(input.data);
-      expect(result?.roomId).to.equal(input.roomId);
-      expect(result?.id).to.be.a("string");
-    });
-
-    it("should create memory with embedding", async () => {
-      const input = {
-        data: "test data",
-        query: "test query",
-        roomId: "test-room",
-        embedding: [0.1, 0.2, 0.3],
-      };
-
-      const result = await memory.createMemory(input);
-
-      expect(result?.embedding).to.deep.equal(input.embedding);
-    });
-  });
-
-  describe("Memory Retrieval", () => {
-    it("should retrieve memory by ID", async () => {
-      const result = await memory.getMemoryById("test-id", TEST_ROOM_ID);
-      expect(result).to.deep.equal(testMemory);
-    });
-
-    it("should retrieve memories by index", async () => {
-      const results = await memory.getMemoryByIndex("test query", {
-        roomId: "test-room",
-        limit: 10,
-      });
-
-      expect(results).to.be.an("array");
-      expect(results[0]).to.deep.equal(testMemory);
-    });
-
-    it("should retrieve all memories", async () => {
-      const results = await memory.getAllMemories(TEST_ROOM_ID);
-      expect(results).to.be.an("array");
-    });
-  });
-
-  describe("Memory Clearing", () => {
-    it("should clear memory by ID", async () => {
-      await memory.clearMemoryById("test-id", TEST_ROOM_ID);
-    });
-
-    it("should clear all memories", async () => {
-      await memory.clearAllMemories();
-    });
-  });
-
-  describe("Error Handling", () => {
-    it("should handle errors during memory creation", async () => {
-      mockMemoryService.createMemory = async () => {
-        throw new Error("Creation failed");
-      };
-
-      try {
-        await memory.createMemory({
-          data: "test",
-          roomId: "test",
-        });
-        expect.fail("Should have thrown an error");
-      } catch (error) {
-        expect(error).to.be.instanceOf(Error);
-        expect((error as Error).message).to.equal("Creation failed");
-      }
-    });
-
-    it("should handle errors during memory retrieval", async () => {
-      mockMemoryService.getMemoryById = async () => {
-        throw new Error("Retrieval failed");
-      };
-
-      try {
-        await memory.getMemoryById("test-id", TEST_ROOM_ID);
-        expect.fail("Should have thrown an error");
-      } catch (error) {
-        expect(error).to.be.instanceOf(Error);
-        expect((error as Error).message).to.equal("Retrieval failed");
-      }
-    });
-  });
-
-  describe("Edge Cases", () => {
-    it("should handle undefined embedding", async () => {
-      const input = {
-        data: "test data",
-        query: "test query",
-        roomId: "test-room",
-        embedding: undefined,
-      };
-
-      const result = await memory.createMemory(input);
-      expect(result?.embedding).to.be.null;
-    });
-
-    it("should handle empty query results", async () => {
-      mockMemoryService.getMemoryByIndex = async () => [];
-
-      const results = await memory.getMemoryByIndex("nonexistent", {
-        roomId: "test-room",
-      });
-      expect(results).to.be.an("array").that.is.empty;
-    });
-
-    it("should handle non-existent memory ID", async () => {
-      mockMemoryService.getMemoryById = async () => null;
-
-      const result = await memory.getMemoryById("nonexistent", TEST_ROOM_ID);
-      expect(result).to.be.null;
-    });
-  });
-});

package/test/services/queue.test.ts

@@ -1,286 +0,0 @@
-import { Queue } from "../../services/queue";
-import { ActionSchema, QueueCallbacks, QueueItem } from "../../types";
-import { expect } from "chai";
-import { z } from "zod";
-
-describe("Queue", () => {
-  // Test actions setup
-  const testActions: ActionSchema[] = [
-    {
-      name: "action1",
-      description: "Test action 1",
-      parameters: z.object({}),
-      execute: async (params) => ({ success: true, params }),
-    },
-    {
-      name: "action2",
-      description: "Test action 2",
-      parameters: z.object({}),
-      execute: async (params) => ({ success: true, params }),
-      confirmation: {
-        requireConfirmation: true,
-        message: "Confirm action2?",
-      },
-    },
-    {
-      name: "actionWithError",
-      description: "Test error action",
-      parameters: z.object({}),
-      execute: async () => {
-        throw new Error("Test error");
-      },
-    },
-  ];
-
-  let queue: Queue;
-  let callbacks: QueueCallbacks;
-
-  beforeEach(() => {
-    // Reset callbacks for each test
-    callbacks = {
-      onActionStart: () => {},
-      onActionComplete: () => {},
-      onQueueComplete: () => {},
-      onConfirmationRequired: async () => true,
-    };
-    queue = new Queue(testActions, callbacks);
-  });
-
-  describe("Queue Management", () => {
-    it("should add a single action to the queue", () => {
-      const action: QueueItem = {
-        name: "action1",
-        parameters: [{ name: "param1", value: "value1" }],
-      };
-
-      queue.add(action);
-      expect(queue["queue"]).to.have.lengthOf(1);
-      expect(queue["queue"][0]).to.deep.equal(action);
-    });
-
-    it("should add multiple actions to the queue", () => {
-      const actions: QueueItem[] = [
-        {
-          name: "action1",
-          parameters: [{ name: "param1", value: "value1" }],
-        },
-        {
-          name: "action2",
-          parameters: [{ name: "param2", value: "value2" }],
-        },
-      ];
-
-      queue.add(actions);
-      expect(queue["queue"]).to.have.lengthOf(2);
-      expect(queue["queue"]).to.deep.equal(actions);
-    });
-  });
-
-  describe("Action Execution", () => {
-    it("should execute a single action successfully", async () => {
-      const action: QueueItem = {
-        name: "action1",
-        parameters: [{ name: "param1", value: "value1" }],
-      };
-
-      queue.add(action);
-      const results = await queue.execute();
-      if (!results) {
-        throw new Error("Results are undefined");
-      }
-      expect(results).to.not.be.undefined;
-      expect(results).to.have.lengthOf(1);
-      expect(results[0].name).to.equal("action1");
-      expect(results[0].error).to.be.null;
-      expect(results[0].result).to.deep.include({ success: true });
-    });
-
-    it("should handle action execution errors", async () => {
-      const action: QueueItem = {
-        name: "actionWithError",
-        parameters: [],
-      };
-
-      queue.add(action);
-      const results = await queue.execute();
-      if (!results) {
-        throw new Error("Results are undefined");
-      }
-      expect(results).to.not.be.undefined;
-      expect(results).to.have.lengthOf(1);
-      expect(results[0].name).to.equal("actionWithError");
-      expect(results[0].error).to.equal("Test error");
-      expect(results[0].result).to.be.null;
-    });
-
-    it("should respect confirmation requirements", async () => {
-      let confirmationCalled = false;
-      callbacks.onConfirmationRequired = async () => {
-        confirmationCalled = true;
-        return false; // Reject the confirmation
-      };
-
-      queue = new Queue(testActions, callbacks);
-      const action: QueueItem = {
-        name: "action2", // Action requiring confirmation
-        parameters: [],
-      };
-
-      queue.add(action);
-      const results = await queue.execute();
-      if (!results) {
-        throw new Error("Results are undefined");
-      }
-      expect(results).to.not.be.undefined;
-      expect(confirmationCalled).to.be.true;
-      expect(results[0].cancelled).to.be.true;
-      expect(results[0].error).to.equal("Action cancelled by user");
-    });
-  });
-
-  describe("Parameter Handling", () => {
-    it("should correctly format simple parameters", async () => {
-      const action: QueueItem = {
-        name: "action1",
-        parameters: [
-          { name: "param1", value: "value1" },
-          { name: "param2", value: "value2" },
-        ],
-      };
-
-      queue.add(action);
-      const results = await queue.execute();
-      if (!results) {
-        throw new Error("Results are undefined");
-      }
-      expect(results).to.not.be.undefined;
-      expect(results[0].parameters).to.deep.equal({
-        param1: "value1",
-        param2: "value2",
-      });
-    });
-
-    it("should handle JSON stringified parameters", async () => {
-      const action: QueueItem = {
-        name: "action1",
-        parameters: [
-          {
-            name: "jsonParam",
-            value: JSON.stringify({ name: "test", value: "value" }),
-          },
-        ],
-      };
-
-      queue.add(action);
-      const results = await queue.execute();
-      if (!results) {
-        throw new Error("Results are undefined");
-      }
-      expect(results).to.not.be.undefined;
-      expect(results[0].parameters).to.deep.equal({
-        test: "value",
-      });
-    });
-  });
-
-  describe("Queue Processing State", () => {
-    it("should prevent concurrent queue processing", async () => {
-      const action: QueueItem = {
-        name: "action1",
-        parameters: [],
-      };
-
-      queue.add(action);
-
-      // Start first execution
-      const firstExecution = queue.execute();
-      // Try to execute again while first execution is running
-      const secondExecution = queue.execute();
-
-      const [firstResults, secondResults] = await Promise.all([
-        firstExecution,
-        secondExecution,
-      ]);
-
-      expect(firstResults).to.not.be.undefined;
-      expect(firstResults).to.have.lengthOf(1);
-      expect(secondResults).to.be.undefined;
-    });
-
-    it("should reset processing state after completion", async () => {
-      const action: QueueItem = {
-        name: "action1",
-        parameters: [],
-      };
-
-      queue.add(action);
-      const results = await queue.execute();
-
-      if (!results) {
-        throw new Error("Results are undefined");
-      }
-      expect(results).to.have.lengthOf(1);
-
-      // Verify that isProcessing is reset
-      expect(queue["isProcessing"]).to.be.false;
-
-      // Clear both queue and results before adding new action
-      queue["queue"] = [];
-      queue["results"] = [];
-
-      // Should be able to execute again
-      queue.add(action);
-      const secondResults = await queue.execute();
-
-      if (!secondResults) {
-        throw new Error("Second results are undefined");
-      }
-      expect(secondResults).to.have.lengthOf(1);
-    });
-  });
-
-  describe("Callback Handling", () => {
-    it("should trigger all callbacks in correct order", async () => {
-      const callbackOrder: string[] = [];
-
-      callbacks = {
-        onActionStart: () => callbackOrder.push("start"),
-        onActionComplete: () => callbackOrder.push("complete"),
-        onQueueComplete: () => callbackOrder.push("queueComplete"),
-      };
-
-      queue = new Queue(testActions, callbacks);
-      const action: QueueItem = {
-        name: "action1",
-        parameters: [],
-      };
-
-      queue.add(action);
-      await queue.execute();
-
-      expect(callbackOrder).to.deep.equal([
-        "start",
-        "complete",
-        "queueComplete",
-      ]);
-    });
-
-    it("should handle missing callbacks gracefully", async () => {
-      queue = new Queue(testActions, {}); // No callbacks provided
-      const action: QueueItem = {
-        name: "action1",
-        parameters: [],
-      };
-
-      queue.add(action);
-      const results = await queue.execute();
-
-      if (!results) {
-        throw new Error("Results are undefined");
-      }
-      expect(results).to.not.be.undefined;
-      expect(results).to.have.lengthOf(1);
-      expect(results[0].error).to.be.null;
-    });
-  });
-});

package/utils/experimental-graph-rag.ts

@@ -1,170 +0,0 @@
-import { MeilisearchAdapter } from "../memory/adapters/meilisearch";
-import { AIEmbeddingService } from "../services/embedding";
-import { openai } from "@ai-sdk/openai";
-import { generateObject } from "ai";
-import { z } from "zod";
-
-export const experimentalGraphRag = async (context: {
-  prompt: string;
-  results: any;
-}) => {
-  if (!process.env.MEILISEARCH_API_KEY)
-    throw new Error("MEILISEARCH_API_KEY is not set");
-  if (!process.env.MEILISEARCH_HOST)
-    throw new Error("MEILISEARCH_HOST is not set");
-
-  const memoryManager = new MeilisearchAdapter({
-    apiKey: process.env.MEILISEARCH_API_KEY,
-    host: process.env.MEILISEARCH_HOST,
-  });
-  await memoryManager.init("nodes");
-  await memoryManager.init("edges");
-  const { existingNodes } = await retrieveExistingRelations(
-    memoryManager,
-    "nodes"
-  );
-  const prompt = `
-      User asked: ${context.prompt}
-      Results: ${JSON.stringify(context.results, null, 2)}
-      Existing nodes: ${JSON.stringify(existingNodes, null, 2)}
-      `;
-  console.log("🔍 Prompt:", prompt);
-  const llmMemory = await generateObject({
-    model: openai("gpt-4o"),
-    prompt,
-    schema: z.object({
-      nodes: z.array(
-        z.object({
-          name: z.string(), // Nom de l'entité (ex: Adresse, ETH, Transaction ID)
-          metadata: z.record(z.string(), z.any()), // Métadonnées associées
-        })
-      ),
-      edges: z.array(
-        z.object({
-          source: z.string(), // ID de l'entité source
-          target: z.string(), // ID de l'entité cible
-          relation: z.string(), // Type de relation (ex: "sent", "received", "on_chain")
-        })
-      ),
-    }),
-    system: `
-       You are an **AI memory manager** for a crypto wallet assistant.
-  
-  ## Rules:
-  - Nodes are entities like user, networks, tokens...etc
-  - Relations are edges like sent, uses, supported_on, loves, has_website...etc
-  - Ensure NO DUPLICATE RELATIONS.
-  - Standardize all relations using Cypher language.
-
-  Return the structured memory in JSON format, ensuring it follows the schema.
-
-        Generate structured graph data accordingly.
-
-        Format the output as a JSON object :
-        {
-          nodes: [
-            {
-              name: string,
-              metadata: Record<string, any>,
-            },
-          ],
-          edges: [
-            {
-              source: string,
-              target: string,
-              relation: string,
-            },
-          ],
-        }
-        `,
-  });
-
-  console.log("🔍 LLM memory (graph-based):");
-  console.log("Nodes:");
-  console.dir(llmMemory.object.nodes, { depth: null, colors: true });
-  console.log("Edges:");
-  console.dir(llmMemory.object.edges, { depth: null, colors: true });
-
-  const embeddingManager = new AIEmbeddingService(
-    openai.embedding("text-embedding-3-small")
-  );
-  const embedding = await embeddingManager.embedText(context.prompt);
-  let nodesNameToId: Record<string, string> = {};
-  for (const node of llmMemory.object.nodes) {
-    // Search for existing memory with same data and query
-    const searchResults = await memoryManager.search(node.name, "nodes", {
-      limit: 1,
-    });
-    const existingMemory = searchResults.find(
-      (result) =>
-        result.document.data.name === node.name &&
-        result.document.roomId === "nodes"
-    );
-
-    // If found, return existing memory
-    if (existingMemory) {
-      nodesNameToId[node.name] = existingMemory.document.id;
-    } else {
-      const nodesMemory = await memoryManager.createMemory({
-        data: node,
-        embedding,
-        roomId: "nodes",
-      });
-      nodesNameToId[node.name] = nodesMemory?.id || "";
-    }
-  }
-  for (const edge of llmMemory.object.edges) {
-    // Verify if source and target already exist in memory
-    const searchResults = await memoryManager.search(
-      nodesNameToId[edge.source],
-      "edges",
-      {
-        limit: 100,
-      }
-    );
-    const existingEdge = searchResults.find(
-      (result) =>
-        result.document.data.source === nodesNameToId[edge.source] &&
-        result.document.data.target === nodesNameToId[edge.target] &&
-        result.document.data.relation === edge.relation
-    );
-    if (existingEdge) {
-    } else {
-      await memoryManager.createMemory({
-        data: {
-          source: nodesNameToId[edge.source],
-          target: nodesNameToId[edge.target],
-          relation: edge.relation,
-        },
-        embedding,
-        roomId: "edges",
-      });
-    }
-  }
-};
-
-async function retrieveExistingRelations(
-  memoryManager: MeilisearchAdapter,
-  roomId: string
-) {
-  const existingNodesMemories = await memoryManager.getAllMemories("nodes");
-  const existingEdgesMemories = await memoryManager.getAllMemories("edges");
-  let existingNodes: any[] = [];
-  let existingEdges: any[] = [];
-
-  if (existingNodesMemories.length > 0) {
-    existingNodes = existingNodesMemories.flatMap((memory) => {
-      return {
-        id: memory.id,
-        data: memory.data,
-      };
-    });
-  }
-  if (existingEdgesMemories.length > 0) {
-    existingEdges = existingEdgesMemories.flatMap(
-      (memory) => memory.data || []
-    );
-  }
-
-  return { existingNodes, existingEdges };
-}