@ai.ntellect/core 0.6.0 → 0.6.2

package/index copy.ts

@@ -0,0 +1,81 @@
+export interface NetworkConfig {
+  name: string;
+  id?: number;
+  rpc: string;
+  explorerUrl: string;
+  nativeToken: string; // WETH
+}
+export const networkConfigs: Record<string, NetworkConfig> = {
+  ethereum: {
+    name: "Ethereum Mainnet",
+    id: 1,
+    rpc: "https://eth.llamarpc.com",
+    explorerUrl: "https://etherscan.io",
+    nativeToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+  },
+  polygon: {
+    name: "Polygon Mainnet",
+    id: 137,
+    rpc: "https://polygon.llamarpc.com",
+    explorerUrl: "https://polygonscan.com",
+    nativeToken: "0x0000000000000000000000000000000000001010",
+  },
+  arbitrum: {
+    name: "Arbitrum Mainnet",
+    id: 42161,
+    rpc: "https://arbitrum.llamarpc.com",
+    explorerUrl: "https://arbiscan.io",
+    nativeToken: "0x82af49447d8a07e3bd95bd0d56f35241523fbab1",
+  },
+  base: {
+    name: "Base Mainnet",
+    id: 8453,
+    rpc: "https://base.llamarpc.com",
+    explorerUrl: "https://basescan.org",
+    nativeToken: "0x4200000000000000000000000000000000000006",
+  },
+  solana: {
+    name: "Solana Mainnet",
+    rpc: "https://api.mainnet-beta.solana.com",
+    explorerUrl: "https://solscan.io",
+    nativeToken: "So11111111111111111111111111111111111111112",
+  },
+  sepolia: {
+    name: "Sepolia Testnet",
+    id: 11155111,
+    rpc: "https://rpc.sepolia.ethpandaops.io",
+    explorerUrl: "https://sepolia.etherscan.io",
+    nativeToken: "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14",
+  },
+  baseSepolia: {
+    name: "Base Sepolia Testnet",
+    id: 84532,
+    rpc: "https://base-sepolia-rpc.publicnode.com",
+    explorerUrl: "https://sepolia.basescan.org",
+    nativeToken: "0x4200000000000000000000000000000000000006",
+  },
+};
+
+export const getNetworkProvider = (networkName: string) => {
+  const config = networkConfigs[networkName.toLowerCase()];
+  if (!config) {
+    throw new Error(`Network ${networkName} not supported`);
+  }
+  return { config };
+};
+
+export const ROUTER_ADDRESSES: { [key: string]: string } = {
+  ethereum: "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",
+  sepolia: "0xeE567Fe1712Faf6149d80dA1E6934E354124CfE3",
+  arbitrum: "0x4752ba5dbc23f44d87826276bf6fd6b1c372ad24",
+  polygon: "0xedf6066a2b290C185783862C7F4776A2C8077AD1",
+  base: "0x4752ba5dbc23f44d87826276bf6fd6b1c372ad24",
+  optimism: "0x4A7b5Da61326A6379179b40d00F57E5bbDC962c2",
+  blast: "0xBB66Eb1c5e875933D44DAe661dbD80e5D9B03035",
+  zora: "0xa00F34A632630EFd15223B1968358bA4845bEEC7",
+  worldchain: "0x541aB7c31A119441eF3575F6973277DE0eF460bd",
+};
+
+export const getRouterAddress = (networkName: string) => {
+  return ROUTER_ADDRESSES[networkName.toLowerCase()];
+};

package/index.ts

@@ -5,4 +5,4 @@ export * from "./memory/adapters/meilisearch";
 export * from "./memory/adapters/redis";
 
 export * from "./interfaces";
-export * from "./types";
+export * from "./types";

package/package.json

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

package/test/graph/engine.test.ts

@@ -35,11 +35,9 @@ describe("Graph", () => {
         description: "Starting node",
         execute: async (_params: any, state: SharedState<TestState>) => {
           return graph.updateState({
-            context: {
-              ...state.context,
-              status: "started",
-              step: 1,
-            },
+            ...state.context,
+            status: "started",
+            step: 1,
           });
         },
         relationships: [{ name: "process" }],
@@ -49,11 +47,9 @@ describe("Graph", () => {
         description: "Processing node",
         execute: async (_params: any, state: SharedState<TestState>) => {
           return graph.updateState({
-            context: {
-              ...state.context,
-              status: "processing",
-              step: 2,
-            },
+            ...state.context,
+            status: "processing",
+            step: 2,
           });
         },
         condition: (state) => state.context.step === 1,
@@ -64,11 +60,9 @@ describe("Graph", () => {
         description: "End node",
         execute: async (_params: any, state: SharedState<TestState>) => {
           return graph.updateState({
-            context: {
-              ...state.context,
-              status: "completed",
-              step: 3,
-            },
+            ...state.context,
+            status: "completed",
+            step: 3,
           });
         },
         relationships: [],
@@ -145,18 +139,15 @@ describe("Graph", () => {
         description: "A new test node",
         execute: async (_params: any, state: SharedState<TestState>) => {
           return graph.updateState({
-            context: {
-              ...state.context,
-              status: "new",
-              step: 4,
-            },
+            ...state.context,
+            status: "new",
+            step: 4,
           });
         },
+        relationships: [{ name: "end" }],
       };
 
-      graph.addNode(newNode, {
-        relationships: [{ name: "end" }],
-      });
+      graph.addNode(newNode);
 
       expect(graph.nodes.has("new-node")).to.be.true;
       const addedNode = graph.nodes.get("new-node");
@@ -174,11 +165,9 @@ describe("Graph", () => {
             description: "New step node",
             execute: async (_params: any, state: SharedState<TestState>) => {
               return graph.updateState({
-                context: {
-                  ...state.context,
-                  status: "new-step",
-                  step: 4,
-                },
+                ...state.context,
+                status: "new-step",
+                step: 4,
               });
             },
             relationships: [],
@@ -218,9 +207,7 @@ describe("Graph", () => {
       graph.setState(initialState);
 
       const partialUpdate = {
-        context: {
-          status: "updated",
-        },
+        status: "updated",
       };
 
       const updatedState = graph.updateState(partialUpdate);
@@ -241,7 +228,7 @@ describe("Graph", () => {
         },
       };
 
-      graph.addNode(errorNode, {});
+      graph.addNode(errorNode);
 
       let errorCaught = false;
       try {
@@ -316,7 +303,7 @@ describe("Graph", () => {
       }));
 
       parallelNodes.forEach((node) => {
-        graph.addNode(node, {});
+        graph.addNode(node);
       });
 
       await graph.executeParallel(
@@ -341,17 +328,15 @@ describe("Graph", () => {
         name: "event-node",
         execute: async (_params: any, state: SharedState<TestState>) => {
           return graph.updateState({
-            context: {
-              ...state.context,
-              status: "event-triggered",
-              step: 10,
-            },
+            ...state.context,
+            status: "event-triggered",
+            step: 10,
           });
         },
         events: ["test-event"],
       };
 
-      graph.addNode(eventNode, { events: ["test-event"] });
+      graph.addNode(eventNode);
 
       // Émettre l'événement
       graph.emit("test-event", {
@@ -382,11 +367,9 @@ describe("Graph", () => {
             name: "sub-start",
             execute: async (_params: any, state: SharedState<TestState>) => {
               return graph.updateState({
-                context: {
-                  ...state.context,
-                  status: "sub-completed",
-                  step: 100,
-                },
+                ...state.context,
+                status: "sub-completed",
+                step: 100,
               });
             },
             relationships: [],

package/tsconfig.json

@@ -12,5 +12,5 @@
     },
     "outDir": "./dist"
   },
-  "exclude": ["examples"]
+  "exclude": ["node_modules", "examples", "test"]
 }

package/types/index.ts

@@ -192,9 +192,7 @@ export type GraphDefinition<T> = {
  * @typedef {Object} SharedState
  * @property {Partial<T>} context - The execution context.
  */
-export type SharedState<T> = {
-  context: Partial<T>;
-};
+export type SharedState<T> = T;
 
 /**
  * Defines a graph node within a graph execution structure.
@@ -268,3 +266,13 @@ export type MeilisearchSettings = {
   searchableAttributes?: string[];
   sortableAttributes?: string[];
 };
+
+/* ======================== ACTIONS ======================== */
+
+export type Action = {
+  name: string;
+  parameters: {
+    name: string;
+    value: string;
+  }[];
+};

package/utils/setup-graphs.ts

@@ -0,0 +1,45 @@
+import { GraphEngine } from "../graph/engine";
+import { Action, GraphDefinition, SharedState } from "../types";
+
+export function setupGraphsWithActions<T>(
+  actions: Action[],
+  baseStateMapping: Record<string, SharedState<T>>,
+  graphMaps: GraphDefinition<T>[]
+): {
+  initialStates: SharedState<T>[];
+  graphs: GraphEngine<T>[];
+  startNodes: string[];
+} {
+  const initialStates = actions.map((action) => {
+    const parametersObject = Object.fromEntries(
+      action.parameters.map((param) => [
+        param.name,
+        param.value !== undefined ? param.value : null,
+      ]) // Handle optional values
+    );
+
+    const baseState = baseStateMapping[action.name] || {};
+
+    return {
+      ...baseState,
+      ...parametersObject,
+    };
+  });
+
+  const selectedGraphs = actions
+    .map((action) => graphMaps.find((graph) => graph.name === action.name))
+    .filter((graph): graph is GraphDefinition<T> => graph !== undefined);
+
+  if (selectedGraphs.length !== actions.length) {
+    throw new Error("Graph not found");
+  }
+
+  const startNodes = selectedGraphs.map((graph) => graph.entryNode);
+  const graphEngines = selectedGraphs.map((graph) => new GraphEngine(graph));
+
+  return {
+    initialStates: initialStates as SharedState<T>[],
+    graphs: graphEngines,
+    startNodes,
+  };
+}

package/utils/stringifiy-zod-schema.ts

@@ -0,0 +1,45 @@
+import { Node } from "@/types";
+import { z } from "zod";
+
+export const stringifyZodSchema = <T>(nodes: Node<T>[]) => {
+  return nodes
+    .map((node) => {
+      const schemaStr = node.schema
+        ? getSchemaString(node.schema)
+        : "No parameters";
+      return `Workflow: ${node.name}\nDescription: ${node.description}\nParameters: ${schemaStr}`;
+    })
+    .join("\n\n");
+};
+
+const getSchemaString = (schema: z.ZodType): string => {
+  if (schema instanceof z.ZodObject) {
+    const entries = Object.entries(schema.shape);
+    const fields = entries.map(([key, value]) => {
+      const description = (value as any)._def.description;
+      const schemaStr = getSchemaString(value as z.ZodType);
+      return description
+        ? `${key}: ${schemaStr} // ${description}`
+        : `${key}: ${schemaStr}`;
+    });
+    return `z.object({${fields.join(", ")}})`;
+  }
+
+  if (schema instanceof z.ZodArray) {
+    return `z.array(${getSchemaString(schema.element)})`;
+  }
+
+  if (schema instanceof z.ZodString) {
+    return "z.string()";
+  }
+
+  if (schema instanceof z.ZodNumber) {
+    return "z.number()";
+  }
+
+  if (schema instanceof z.ZodBoolean) {
+    return "z.boolean()";
+  }
+
+  return `z.unknown()`;
+};

package/dist/test/graph/controller.test.js

@@ -1,170 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const controller_1 = require("@/graph/controller");
-const chai_1 = require("chai");
-const zod_1 = require("zod");
-describe("Controller", () => {
-    // Define test schema
-    const TestSchema = zod_1.z.object({
-        status: zod_1.z.string(),
-        count: zod_1.z.number(),
-    });
-    // Sample workflow definitions
-    const simpleWorkflow = {
-        name: "simple-workflow",
-        entryNode: "start",
-        nodes: {
-            start: {
-                name: "start",
-                execute: (_params, state) => __awaiter(void 0, void 0, void 0, function* () {
-                    return ({
-                        context: Object.assign(Object.assign({}, state.context), { status: "completed", count: state.context.count + 1 }),
-                    });
-                }),
-                relationships: [],
-            },
-        },
-        schema: TestSchema,
-    };
-    const complexWorkflow = {
-        name: "complex-workflow",
-        entryNode: "first",
-        nodes: {
-            first: {
-                name: "first",
-                execute: (_params, state) => __awaiter(void 0, void 0, void 0, function* () {
-                    return ({
-                        context: Object.assign(Object.assign({}, state.context), { status: "step1", count: state.context.count + 2 }),
-                    });
-                }),
-                relationships: [],
-            },
-        },
-        schema: TestSchema,
-    };
-    let controller;
-    beforeEach(() => {
-        controller = new controller_1.GraphController();
-    });
-    describe("Basic Execution", () => {
-        it("should execute a single workflow successfully", () => __awaiter(void 0, void 0, void 0, function* () {
-            const actions = [
-                {
-                    name: "simple-workflow",
-                    parameters: [
-                        { name: "status", value: "initial" },
-                        { name: "count", value: 0 },
-                    ],
-                },
-            ];
-            const result = yield controller.run(actions, [simpleWorkflow]);
-            (0, chai_1.expect)(result.context).to.deep.equal({
-                status: "completed",
-                count: 1,
-            });
-        }));
-        it("should handle multiple workflows", () => __awaiter(void 0, void 0, void 0, function* () {
-            const actions = [
-                {
-                    name: "complex-workflow",
-                    parameters: [
-                        { name: "status", value: "initial" },
-                        { name: "count", value: 0 },
-                    ],
-                },
-            ];
-            const result = yield controller.run(actions, [
-                simpleWorkflow,
-                complexWorkflow,
-            ]);
-            (0, chai_1.expect)(result.context).to.deep.equal({
-                status: "step1",
-                count: 2,
-            });
-        }));
-    });
-    describe("Error Handling", () => {
-        it("should throw error when no actions provided", () => __awaiter(void 0, void 0, void 0, function* () {
-            try {
-                yield controller.run([], [simpleWorkflow]);
-                chai_1.expect.fail("Should have thrown an error");
-            }
-            catch (error) {
-                (0, chai_1.expect)(error.message).to.equal("No actions provided");
-            }
-        }));
-        it("should throw error when workflow not found", () => __awaiter(void 0, void 0, void 0, function* () {
-            const actions = [
-                {
-                    name: "non-existent-workflow",
-                    parameters: [
-                        { name: "status", value: "initial" },
-                        { name: "count", value: 0 },
-                    ],
-                },
-            ];
-            try {
-                yield controller.run(actions, [simpleWorkflow]);
-                chai_1.expect.fail("Should have thrown an error");
-            }
-            catch (error) {
-                (0, chai_1.expect)(error.message).to.equal("Graph not found: non-existent-workflow");
-            }
-        }));
-    });
-    describe("Parameter Handling", () => {
-        it("should correctly process workflow parameters", () => __awaiter(void 0, void 0, void 0, function* () {
-            const actions = [
-                {
-                    name: "simple-workflow",
-                    parameters: [
-                        { name: "status", value: "custom-initial" },
-                        { name: "count", value: 10 },
-                    ],
-                },
-            ];
-            const result = yield controller.run(actions, [simpleWorkflow]);
-            (0, chai_1.expect)(result.context).to.deep.equal({
-                status: "completed",
-                count: 11,
-            });
-        }));
-    });
-    describe("Multiple Actions", () => {
-        it("should process the first action only", () => __awaiter(void 0, void 0, void 0, function* () {
-            const actions = [
-                {
-                    name: "simple-workflow",
-                    parameters: [
-                        { name: "status", value: "initial" },
-                        { name: "count", value: 0 },
-                    ],
-                },
-                {
-                    name: "complex-workflow",
-                    parameters: [
-                        { name: "status", value: "initial" },
-                        { name: "count", value: 5 },
-                    ],
-                },
-            ];
-            const result = yield controller.run(actions, [
-                simpleWorkflow,
-                complexWorkflow,
-            ]);
-            (0, chai_1.expect)(result.context).to.deep.equal({
-                status: "completed",
-                count: 1,
-            });
-        }));
-    });
-});