@ai.ntellect/core 0.6.1 → 0.6.2

package/dist/index copy.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRouterAddress = exports.ROUTER_ADDRESSES = exports.getNetworkProvider = exports.networkConfigs = void 0;
+exports.networkConfigs = {
+    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",
+    },
+};
+const getNetworkProvider = (networkName) => {
+    const config = exports.networkConfigs[networkName.toLowerCase()];
+    if (!config) {
+        throw new Error(`Network ${networkName} not supported`);
+    }
+    return { config };
+};
+exports.getNetworkProvider = getNetworkProvider;
+exports.ROUTER_ADDRESSES = {
+    ethereum: "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",
+    sepolia: "0xeE567Fe1712Faf6149d80dA1E6934E354124CfE3",
+    arbitrum: "0x4752ba5dbc23f44d87826276bf6fd6b1c372ad24",
+    polygon: "0xedf6066a2b290C185783862C7F4776A2C8077AD1",
+    base: "0x4752ba5dbc23f44d87826276bf6fd6b1c372ad24",
+    optimism: "0x4A7b5Da61326A6379179b40d00F57E5bbDC962c2",
+    blast: "0xBB66Eb1c5e875933D44DAe661dbD80e5D9B03035",
+    zora: "0xa00F34A632630EFd15223B1968358bA4845bEEC7",
+    worldchain: "0x541aB7c31A119441eF3575F6973277DE0eF460bd",
+};
+const getRouterAddress = (networkName) => {
+    return exports.ROUTER_ADDRESSES[networkName.toLowerCase()];
+};
+exports.getRouterAddress = getRouterAddress;

package/dist/utils/setup-graphs.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupGraphsWithActions = setupGraphsWithActions;
+const engine_1 = require("../graph/engine");
+function setupGraphsWithActions(actions, baseStateMapping, graphMaps) {
+    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 Object.assign(Object.assign({}, baseState), parametersObject);
+    });
+    const selectedGraphs = actions
+        .map((action) => graphMaps.find((graph) => graph.name === action.name))
+        .filter((graph) => 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 engine_1.GraphEngine(graph));
+    return {
+        initialStates: initialStates,
+        graphs: graphEngines,
+        startNodes,
+    };
+}

package/dist/utils/stringifiy-zod-schema.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyZodSchema = void 0;
+const zod_1 = require("zod");
+const stringifyZodSchema = (nodes) => {
+    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");
+};
+exports.stringifyZodSchema = stringifyZodSchema;
+const getSchemaString = (schema) => {
+    if (schema instanceof zod_1.z.ZodObject) {
+        const entries = Object.entries(schema.shape);
+        const fields = entries.map(([key, value]) => {
+            const description = value._def.description;
+            const schemaStr = getSchemaString(value);
+            return description
+                ? `${key}: ${schemaStr} // ${description}`
+                : `${key}: ${schemaStr}`;
+        });
+        return `z.object({${fields.join(", ")}})`;
+    }
+    if (schema instanceof zod_1.z.ZodArray) {
+        return `z.array(${getSchemaString(schema.element)})`;
+    }
+    if (schema instanceof zod_1.z.ZodString) {
+        return "z.string()";
+    }
+    if (schema instanceof zod_1.z.ZodNumber) {
+        return "z.number()";
+    }
+    if (schema instanceof zod_1.z.ZodBoolean) {
+        return "z.boolean()";
+    }
+    return `z.unknown()`;
+};

package/graph/controller.ts

@@ -37,15 +37,13 @@ export class GraphController<T> {
       console.log("graph", graph);
 
       // Construct the initial state from action parameters.
-      const initialState = {
-        context: action.parameters.reduce(
-          (acc: Record<string, any>, param: { name: string; value: any }) => {
-            acc[param.name] = param.value;
-            return acc;
-          },
-          {}
-        ),
-      };
+      const initialState = action.parameters.reduce(
+        (acc: Record<string, any>, param: { name: string; value: any }) => {
+          acc[param.name] = param.value;
+          return acc;
+        },
+        {}
+      );
 
       console.log("initialState", initialState);
 

package/graph/engine.ts

@@ -1,11 +1,8 @@
 import { Persistence, RealTimeNotifier } from "@/interfaces";
 import { GraphDefinition, Node, SharedState } from "@/types";
-import { configDotenv } from "dotenv";
 import EventEmitter from "events";
 import { z } from "zod";
 
-configDotenv();
-
 interface GraphOptions<T> {
   initialState?: SharedState<T>;
   schema?: z.ZodSchema<T>;

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.1",
+  "version": "0.6.2",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

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,
-            });
-        }));
-    });
-});