@ai.ntellect/core 0.5.0 → 0.6.1

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/graph/controller.js

@@ -0,0 +1,63 @@
+"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 });
+exports.GraphController = void 0;
+const engine_1 = require("./engine");
+/**
+ * Controller responsible for executing workflows based on graph definitions.
+ * @template T The type representing the graph's state.
+ */
+class GraphController {
+    /**
+     * Executes a sequence of actions using the corresponding graph definitions.
+     * @param {any[]} actions - The list of actions to execute.
+     * @param {GraphDefinition<T>[]} graphs - The available graph definitions.
+     * @returns {Promise<any>} The final state of the executed workflow.
+     * @throws {Error} If no actions are provided or if the graph is not found.
+     */
+    run(actions, graphs) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (actions.length === 0) {
+                throw new Error("No actions provided");
+            }
+            // Create a mapping of graph names to their definitions for quick lookup.
+            const graphMap = new Map(graphs.map((g) => [g.name, g]));
+            for (const action of actions) {
+                // Retrieve the graph definition based on the action name.
+                const graphDefinition = graphMap.get(action.name);
+                if (!graphDefinition) {
+                    throw new Error(`Graph not found: ${action.name}`);
+                }
+                // Initialize the graph engine with the selected graph definition.
+                const graph = new engine_1.GraphEngine(graphDefinition, {
+                    schema: graphDefinition.schema,
+                    autoDetectCycles: true,
+                });
+                // Construct the initial state from action parameters.
+                const initialState = {
+                    context: action.parameters.reduce((acc, param) => {
+                        acc[param.name] = param.value;
+                        return acc;
+                    }, {}),
+                };
+                // Execute the graph starting from the defined entry node.
+                yield graph.execute(initialState, graphDefinition.entryNode);
+                // Retrieve the final state after execution.
+                const result = graph.getState();
+                if (!result) {
+                    throw new Error("Workflow execution failed to return a state");
+                }
+                return result;
+            }
+        });
+    }
+}
+exports.GraphController = GraphController;