@ai.ntellect/core 0.6.1 → 0.6.2

package/dist/create-llm-to-select-multiple-graph copy.js

@@ -0,0 +1,201 @@
+"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());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const openai_1 = require("@ai-sdk/openai");
+const ai_1 = require("ai");
+const ethers_1 = require("ethers");
+const zod_1 = require("zod");
+const engine_1 = require("./graph/engine");
+const index_copy_1 = require("./index copy");
+const setup_graphs_1 = require("./utils/setup-graphs");
+const stringifiy_zod_schema_1 = require("./utils/stringifiy-zod-schema");
+// // 2. Define the graph
+// ---- II. Create an LLM to select the
+// 2. Define the graph with a name
+const graphDefinitionA = {
+    name: "prepare-evm-transaction", // Assign a name to match the workflow
+    entryNode: "prepare-evm-transaction",
+    nodes: {
+        "prepare-evm-transaction": {
+            name: "prepare-evm-transaction",
+            description: "Prepare a transaction for the user to sign.",
+            schema: zod_1.z.object({
+                to: zod_1.z.string(),
+                value: zod_1.z
+                    .string()
+                    .describe("Ask the user for the amount to send, if not specified"),
+                chain: zod_1.z
+                    .string()
+                    .describe("Examples networks: ethereum, arbitrum, base. IMPORTANT: You must respect the network name."),
+            }),
+            execute: (params, state) => __awaiter(void 0, void 0, void 0, function* () {
+                console.log("💰 Prepare transaction", { params, state });
+                const networkConfig = index_copy_1.networkConfigs[params.chain.toLowerCase()];
+                if (!networkConfig) {
+                    throw new Error(`Network ${params.chain} not found`);
+                }
+                return {
+                    to: params.to,
+                    value: (0, ethers_1.parseEther)(params.value).toString(),
+                    chain: {
+                        id: networkConfig.id || 0,
+                        rpc: networkConfig.rpc,
+                    },
+                    type: "transfer",
+                };
+            }),
+        },
+    },
+};
+const graphDefinitionB = {
+    name: "security-analysis",
+    entryNode: "security-analysis",
+    nodes: {
+        "security-analysis": {
+            name: "security-analysis",
+            description: "Get news",
+            execute: () => __awaiter(void 0, void 0, void 0, function* () {
+                return { messages: "Hello, world!" };
+            }),
+            relationships: [{ name: "end" }],
+        },
+        end: {
+            name: "end",
+            description: "End the graph",
+            execute: () => __awaiter(void 0, void 0, void 0, function* () {
+                return {
+                    messages: "Here the security analysis of Bitcoin: Bitcoin is a good investment",
+                };
+            }),
+        },
+    },
+};
+// 3. Define the initial state
+const initialState = {
+    messages: "",
+    reasoning: true,
+};
+const graphMaps = [
+    graphDefinitionA,
+    graphDefinitionB,
+    // Add other graphs
+];
+// ---- II. Create a node with LLM
+(() => __awaiter(void 0, void 0, void 0, function* () {
+    const prompt = "je veux envoyer 0.0001 eth à 0x123 sur ethereum";
+    // Dynamically extract start nodes from each graph definition in graphMaps
+    const reasoningGraphDefinition = {
+        name: "reasoning",
+        entryNode: "reasoning",
+        nodes: {
+            reasoning: {
+                name: "reasoning",
+                description: "Reasoning",
+                execute: (params, state) => __awaiter(void 0, void 0, void 0, function* () {
+                    var _a, e_1, _b, _c;
+                    console.log("Reasoning", { params, state });
+                    const startNodesSchema = graphMaps.map((graphDefinition) => graphDefinition.nodes[graphDefinition.entryNode]);
+                    // Pass the start nodes into stringifyZodSchema
+                    const system = `You are a wallet assistant. Don't reuse the same workflow multiple times.
+        Here the available workflows and parameters:
+        workflows:${(0, stringifiy_zod_schema_1.stringifyZodSchema)(startNodesSchema)}`;
+                    console.log(system);
+                    const llm = yield (0, ai_1.streamObject)({
+                        model: (0, openai_1.openai)("gpt-4o"),
+                        prompt,
+                        schema: zod_1.z.object({
+                            actions: zod_1.z.array(zod_1.z.object({
+                                name: zod_1.z.string(),
+                                parameters: zod_1.z.array(zod_1.z.object({
+                                    name: zod_1.z.string(),
+                                    value: zod_1.z.any(),
+                                })),
+                            })),
+                            response: zod_1.z.string(),
+                        }),
+                        system,
+                    });
+                    console.dir(llm.object, { depth: null });
+                    try {
+                        for (var _d = true, _e = __asyncValues(llm.partialObjectStream), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                            _c = _f.value;
+                            _d = false;
+                            const chunk = _c;
+                            if (chunk.response) {
+                                // console.log(chunk.response);
+                            }
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    const actions = (yield llm.object).actions;
+                    console.log({ actions });
+                    const selectedWorkflows = (yield llm.object).actions;
+                    return {
+                        messages: "Hello, world!",
+                        actions: selectedWorkflows,
+                    };
+                }),
+                condition: (state) => {
+                    return state.reasoning === true;
+                },
+                relationships: [{ name: "actions" }],
+            },
+            actions: {
+                name: "actions",
+                description: "Actions",
+                execute: (parameters, state) => __awaiter(void 0, void 0, void 0, function* () {
+                    if (!state.actions) {
+                        throw new Error("No actions found");
+                    }
+                    const baseStateMapping = {
+                        "prepare-evm-transaction": initialState,
+                        // Add other workflows and their base states as needed
+                    };
+                    const { initialStates, graphs: selectedGraphs, startNodes, } = (0, setup_graphs_1.setupGraphsWithActions)(state.actions, baseStateMapping, graphMaps);
+                    // Execute graphs with dynamically determined initial states
+                    const results = yield engine_1.GraphEngine.executeGraphsInSequence(selectedGraphs, startNodes, initialStates, (graph) => {
+                        console.log(`Graph ${graph.name} updated`, graph.getState());
+                    }, (error, nodeName, state) => {
+                        console.error(`Erreur dans ${nodeName}`, error, state);
+                    });
+                    console.log({ results });
+                    return {
+                        messages: "Hello, world!",
+                        results,
+                    };
+                }),
+                condition: (state) => {
+                    if (state.reasoning === true &&
+                        state.actions &&
+                        state.actions.length > 0) {
+                        return true;
+                    }
+                    return false;
+                },
+            },
+        },
+    };
+    const reasoningGraph = new engine_1.GraphEngine(reasoningGraphDefinition);
+    yield reasoningGraph.execute(initialState, "reasoning");
+}))();

package/dist/create-llm-to-select-multiple-graph.js

@@ -0,0 +1,142 @@
+"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());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const openai_1 = require("@ai-sdk/openai");
+const ai_1 = require("ai");
+const zod_1 = require("zod");
+const engine_1 = require("./graph/engine");
+const setup_graphs_1 = require("./utils/setup-graphs");
+const stringifiy_zod_schema_1 = require("./utils/stringifiy-zod-schema");
+// // 2. Define the graph
+// ---- II. Create an LLM to select the
+// 2. Define the graph with a name
+const graphDefinitionA = {
+    name: "get-news", // Assign a name to match the workflow
+    entryNode: "get-news",
+    nodes: {
+        "get-news": {
+            name: "get-news",
+            description: "Get news",
+            schema: zod_1.z.object({
+                query: zod_1.z.string(),
+            }),
+            execute: () => __awaiter(void 0, void 0, void 0, function* () {
+                return { messages: "Hello, world!" };
+            }),
+            relationships: [{ name: "end" }],
+        },
+        end: {
+            name: "end",
+            description: "End the graph",
+            execute: () => __awaiter(void 0, void 0, void 0, function* () {
+                return { messages: "Goodbye, world!" };
+            }),
+        },
+    },
+};
+const graphDefinitionB = {
+    name: "security-analysis",
+    entryNode: "security-analysis",
+    nodes: {
+        "security-analysis": {
+            name: "security-analysis",
+            description: "Get news",
+            execute: () => __awaiter(void 0, void 0, void 0, function* () {
+                return { messages: "Hello, world!" };
+            }),
+            relationships: [{ name: "end" }],
+        },
+        end: {
+            name: "end",
+            description: "End the graph",
+            execute: () => __awaiter(void 0, void 0, void 0, function* () {
+                return { messages: "Goodbye, world!" };
+            }),
+        },
+    },
+};
+// 3. Define the initial state
+const initialState = {
+    messages: "",
+};
+// 3. Define the initial state
+const initialStateB = {
+    messages: "",
+};
+const graphMaps = [graphDefinitionA, graphDefinitionB];
+// ---- II. Create a node with LLM
+(() => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, e_1, _b, _c;
+    const prompt = "Salut quelles sont les news sur bitcoin ? et fais une analyse de sécurité";
+    // Dynamically extract start nodes from each graph definition in graphMaps
+    const startNodesSchema = graphMaps.map((graphDefinition) => graphDefinition.nodes[graphDefinition.entryNode]);
+    // Pass the start nodes into stringifyZodSchema
+    const system = `You can select multiple workflows.
+Here the available workflows and parameters:
+workflows:${(0, stringifiy_zod_schema_1.stringifyZodSchema)(startNodesSchema)}`;
+    console.log(system);
+    const llm = yield (0, ai_1.streamObject)({
+        model: (0, openai_1.openai)("gpt-4o"),
+        prompt,
+        schema: zod_1.z.object({
+            actions: zod_1.z.array(zod_1.z.object({
+                name: zod_1.z.string(),
+                parameters: zod_1.z.array(zod_1.z.object({
+                    name: zod_1.z.string(),
+                    value: zod_1.z.any(),
+                })),
+            })),
+            response: zod_1.z.string(),
+        }),
+        system,
+    });
+    try {
+        for (var _d = true, _e = __asyncValues(llm.partialObjectStream), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+            _c = _f.value;
+            _d = false;
+            const chunk = _c;
+            if (chunk.response) {
+                console.log(chunk.response);
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    const actions = (yield llm.object).actions;
+    console.log(actions);
+    const selectedWorkflows = (yield llm.object).actions;
+    console.dir(llm.object, { depth: null });
+    // Define the base states
+    const baseStateMapping = {
+        "get-news": initialState,
+        "security-analysis": initialStateB,
+        // Add other workflows and their base states as needed
+    };
+    const { initialStates, graphs: selectedGraphs, startNodes, } = (0, setup_graphs_1.setupGraphsWithActions)(selectedWorkflows, baseStateMapping, graphMaps);
+    // Execute graphs with dynamically determined initial states
+    engine_1.GraphEngine.executeGraphsInParallel(selectedGraphs, startNodes, initialStates, (graph) => {
+        console.log(`Graph ${graph.name} updated`, graph.getState());
+    }, (error, nodeName, state) => {
+        console.error(`Erreur dans ${nodeName}`, error, state);
+    });
+}))();

package/dist/graph/controller.js

@@ -41,13 +41,13 @@ class GraphController {
                     schema: graphDefinition.schema,
                     autoDetectCycles: true,
                 });
+                console.log("graph", graph);
                 // Construct the initial state from action parameters.
-                const initialState = {
-                    context: action.parameters.reduce((acc, param) => {
-                        acc[param.name] = param.value;
-                        return acc;
-                    }, {}),
-                };
+                const initialState = action.parameters.reduce((acc, param) => {
+                    acc[param.name] = param.value;
+                    return acc;
+                }, {});
+                console.log("initialState", initialState);
                 // Execute the graph starting from the defined entry node.
                 yield graph.execute(initialState, graphDefinition.entryNode);
                 // Retrieve the final state after execution.