@ai.ntellect/core 0.6.0 → 0.6.2

package/create-llm-to-select-multiple-graph copy.ts

@@ -0,0 +1,243 @@
+import { openai } from "@ai-sdk/openai";
+import { streamObject } from "ai";
+import { parseEther } from "ethers";
+import { z } from "zod";
+import { GraphEngine } from "./graph/engine";
+import { networkConfigs } from "./index copy";
+import { Action, GraphDefinition, SharedState } from "./types";
+import { setupGraphsWithActions } from "./utils/setup-graphs";
+import { stringifyZodSchema } from "./utils/stringifiy-zod-schema";
+// ---- I. Create a simple workflow ----
+// 1. Define the context
+type MainContext = {
+  messages: string;
+  reasoning?: boolean;
+  actions?: Action[];
+};
+
+type ContextA = {
+  to: string;
+  value: string;
+  chain: {
+    id: number;
+    rpc: string;
+  };
+  type: string;
+};
+
+type ContextB = {
+  messages: string;
+};
+
+// // 2. Define the graph
+
+// ---- II. Create an LLM to select the
+
+// 2. Define the graph with a name
+const graphDefinitionA: GraphDefinition<ContextA> = {
+  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: z.object({
+        to: z.string(),
+        value: z
+          .string()
+          .describe("Ask the user for the amount to send, if not specified"),
+        chain: z
+          .string()
+          .describe(
+            "Examples networks: ethereum, arbitrum, base. IMPORTANT: You must respect the network name."
+          ),
+      }),
+      execute: async (params, state) => {
+        console.log("💰 Prepare transaction", { params, state });
+        const networkConfig = networkConfigs[params.chain.toLowerCase()];
+
+        if (!networkConfig) {
+          throw new Error(`Network ${params.chain} not found`);
+        }
+
+        return {
+          to: params.to,
+          value: parseEther(params.value).toString(),
+          chain: {
+            id: networkConfig.id || 0,
+            rpc: networkConfig.rpc,
+          },
+          type: "transfer",
+        };
+      },
+    },
+  },
+};
+
+const graphDefinitionB: GraphDefinition<ContextB> = {
+  name: "security-analysis",
+  entryNode: "security-analysis",
+  nodes: {
+    "security-analysis": {
+      name: "security-analysis",
+      description: "Get news",
+      execute: async () => {
+        return { messages: "Hello, world!" };
+      },
+      relationships: [{ name: "end" }],
+    },
+    end: {
+      name: "end",
+      description: "End the graph",
+      execute: async () => {
+        return {
+          messages:
+            "Here the security analysis of Bitcoin: Bitcoin is a good investment",
+        };
+      },
+    },
+  },
+};
+// 3. Define the initial state
+const initialState: SharedState<MainContext> = {
+  messages: "",
+  reasoning: true,
+};
+type CombinedContext = ContextA | ContextB;
+
+const graphMaps: GraphDefinition<CombinedContext>[] = [
+  graphDefinitionA as GraphDefinition<CombinedContext>,
+  graphDefinitionB as GraphDefinition<CombinedContext>,
+  // Add other graphs
+];
+
+// ---- II. Create a node with LLM
+(async () => {
+  const prompt = "je veux envoyer 0.0001 eth à 0x123 sur ethereum";
+  // Dynamically extract start nodes from each graph definition in graphMaps
+
+  const reasoningGraphDefinition: GraphDefinition<MainContext> = {
+    name: "reasoning",
+    entryNode: "reasoning",
+    nodes: {
+      reasoning: {
+        name: "reasoning",
+        description: "Reasoning",
+        execute: async (params, state) => {
+          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:${stringifyZodSchema(startNodesSchema)}`;
+          console.log(system);
+
+          const llm = await streamObject({
+            model: openai("gpt-4o"),
+            prompt,
+            schema: z.object({
+              actions: z.array(
+                z.object({
+                  name: z.string(),
+                  parameters: z.array(
+                    z.object({
+                      name: z.string(),
+                      value: z.any(),
+                    })
+                  ),
+                })
+              ),
+              response: z.string(),
+            }),
+            system,
+          });
+          console.dir(llm.object, { depth: null });
+
+          for await (const chunk of llm.partialObjectStream) {
+            if (chunk.response) {
+              // console.log(chunk.response);
+            }
+          }
+
+          const actions = (await llm.object).actions;
+          console.log({ actions });
+
+          const selectedWorkflows = (await llm.object).actions as Action[];
+          return {
+            messages: "Hello, world!",
+            actions: selectedWorkflows,
+          };
+        },
+        condition: (state) => {
+          return state.reasoning === true;
+        },
+        relationships: [{ name: "actions" }],
+      },
+      actions: {
+        name: "actions",
+        description: "Actions",
+        execute: async (parameters, state) => {
+          if (!state.actions) {
+            throw new Error("No actions found");
+          }
+          const baseStateMapping: Record<
+            string,
+            SharedState<CombinedContext>
+          > = {
+            "prepare-evm-transaction": initialState,
+            // Add other workflows and their base states as needed
+          };
+
+          const {
+            initialStates,
+            graphs: selectedGraphs,
+            startNodes,
+          } = setupGraphsWithActions(
+            state.actions,
+            baseStateMapping,
+            graphMaps
+          );
+
+          // Execute graphs with dynamically determined initial states
+          const results =
+            await GraphEngine.executeGraphsInSequence<CombinedContext>(
+              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 GraphEngine(reasoningGraphDefinition);
+  await reasoningGraph.execute(initialState, "reasoning");
+})();

package/create-llm-to-select-multiple-graph.ts

@@ -0,0 +1,148 @@
+import { openai } from "@ai-sdk/openai";
+import { streamObject } from "ai";
+import { z } from "zod";
+import { GraphEngine } from "./graph/engine";
+import { Action, GraphDefinition, Node, SharedState } from "./types";
+import { setupGraphsWithActions } from "./utils/setup-graphs";
+import { stringifyZodSchema } from "./utils/stringifiy-zod-schema";
+
+// ---- I. Create a simple workflow ----
+// 1. Define the context
+type Context = {
+  messages: string;
+};
+
+// // 2. Define the graph
+
+// ---- II. Create an LLM to select the
+
+// 2. Define the graph with a name
+const graphDefinitionA: GraphDefinition<Context> = {
+  name: "get-news", // Assign a name to match the workflow
+  entryNode: "get-news",
+  nodes: {
+    "get-news": {
+      name: "get-news",
+      description: "Get news",
+      schema: z.object({
+        query: z.string(),
+      }),
+      execute: async () => {
+        return { messages: "Hello, world!" };
+      },
+      relationships: [{ name: "end" }],
+    },
+    end: {
+      name: "end",
+      description: "End the graph",
+      execute: async () => {
+        return { messages: "Goodbye, world!" };
+      },
+    },
+  },
+};
+
+const graphDefinitionB: GraphDefinition<Context> = {
+  name: "security-analysis",
+  entryNode: "security-analysis",
+  nodes: {
+    "security-analysis": {
+      name: "security-analysis",
+      description: "Get news",
+      execute: async () => {
+        return { messages: "Hello, world!" };
+      },
+      relationships: [{ name: "end" }],
+    },
+    end: {
+      name: "end",
+      description: "End the graph",
+      execute: async () => {
+        return { messages: "Goodbye, world!" };
+      },
+    },
+  },
+};
+// 3. Define the initial state
+const initialState: SharedState<Context> = {
+  messages: "",
+};
+
+// 3. Define the initial state
+const initialStateB: SharedState<Context> = {
+  messages: "",
+};
+const graphMaps = [graphDefinitionA, graphDefinitionB];
+
+// ---- II. Create a node with LLM
+(async () => {
+  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:${stringifyZodSchema(startNodesSchema)}`;
+  console.log(system);
+
+  const llm = await streamObject({
+    model: openai("gpt-4o"),
+    prompt,
+    schema: z.object({
+      actions: z.array(
+        z.object({
+          name: z.string(),
+          parameters: z.array(
+            z.object({
+              name: z.string(),
+              value: z.any(),
+            })
+          ),
+        })
+      ),
+      response: z.string(),
+    }),
+    system,
+  });
+
+  for await (const chunk of llm.partialObjectStream) {
+    if (chunk.response) {
+      console.log(chunk.response);
+    }
+  }
+
+  const actions = (await llm.object).actions;
+  console.log(actions);
+
+  const selectedWorkflows = (await llm.object).actions as Action[];
+  console.dir(llm.object, { depth: null });
+  // Define the base states
+  const baseStateMapping: Record<string, SharedState<Context>> = {
+    "get-news": initialState,
+    "security-analysis": initialStateB,
+    // Add other workflows and their base states as needed
+  };
+
+  const {
+    initialStates,
+    graphs: selectedGraphs,
+    startNodes,
+  } = setupGraphsWithActions(selectedWorkflows, baseStateMapping, graphMaps);
+
+  // Execute graphs with dynamically determined initial states
+  GraphEngine.executeGraphsInParallel<Context>(
+    selectedGraphs,
+    startNodes,
+    initialStates,
+    (graph) => {
+      console.log(`Graph ${graph.name} updated`, graph.getState());
+    },
+    (error, nodeName, state) => {
+      console.error(`Erreur dans ${nodeName}`, error, state);
+    }
+  );
+})();

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");
+}))();