@ai.ntellect/core 0.6.0 → 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

@@ -34,16 +34,18 @@ export class GraphController<T> {
         autoDetectCycles: true,
       });
 
+      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);
 
       // Execute the graph starting from the defined entry node.
       await graph.execute(initialState, graphDefinition.entryNode);