@ai.ntellect/core 0.6.10 → 0.6.12

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

@@ -1,237 +0,0 @@
-import { openai } from "@ai-sdk/openai";
-import { generateObject } 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 = {
-  results?: Record<string, CombinedContext>[];
-  actions?: Action[];
-};
-
-type ContextA = {
-  to: string;
-  value: string;
-  chain: {
-    id: number;
-    rpc: string;
-  };
-  type: string;
-};
-
-type ContextB = {};
-
-// // 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 (state) => {
-        console.log("💰 Prepare transaction", { state });
-        const networkConfig =
-          networkConfigs[(state.chain as any).toLowerCase()];
-
-        if (!networkConfig) {
-          throw new Error(`Network ${state.chain} not found`);
-        }
-
-        return {
-          to: state.to,
-          value: parseEther(state.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> = {};
-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 (state) => {
-          console.log("Reasoning", { 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 generateObject({
-            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 });
-
-          const actions = (await llm.object).actions;
-          console.log({ actions });
-
-          const selectedWorkflows = (await llm.object).actions as Action[];
-          return {
-            messages: "Hello, world!",
-            actions: selectedWorkflows,
-          };
-        },
-        relationships: [{ name: "actions" }],
-      },
-      actions: {
-        name: "actions",
-        description: "Actions",
-        execute: async (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,
-              state.actions,
-              (graph) => {
-                console.log(`Graph ${graph.name} updated`, graph.getState());
-              },
-              (
-                error: Error,
-                nodeName: string,
-                state: SharedState<CombinedContext>
-              ) => {
-                console.error(`Erreur dans ${nodeName}`, error, state);
-              }
-            );
-
-          return {
-            actions: results,
-          };
-        },
-        condition: (state) => {
-          if (state.actions && state.actions.length > 0) {
-            return true;
-          }
-          return false;
-        },
-      },
-    },
-  };
-
-  const reasoningGraph = new GraphEngine(reasoningGraphDefinition);
-  await reasoningGraph.execute(
-    initialState,
-    "reasoning",
-    (graph) => {
-      console.log("Main graph updated", graph.name);
-      console.dir(graph.getState(), { depth: null });
-    },
-    (error, nodeName, state) => {
-      console.error(`Erreur dans ${nodeName}`, error, state);
-    }
-  );
-})();

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

@@ -1,148 +0,0 @@
-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

@@ -1,171 +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 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: (state) => __awaiter(void 0, void 0, void 0, function* () {
-                console.log("💰 Prepare transaction", { state });
-                const networkConfig = index_copy_1.networkConfigs[state.chain.toLowerCase()];
-                if (!networkConfig) {
-                    throw new Error(`Network ${state.chain} not found`);
-                }
-                return {
-                    to: state.to,
-                    value: (0, ethers_1.parseEther)(state.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 = {};
-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: (state) => __awaiter(void 0, void 0, void 0, function* () {
-                    console.log("Reasoning", { 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.generateObject)({
-                        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 });
-                    const actions = (yield llm.object).actions;
-                    console.log({ actions });
-                    const selectedWorkflows = (yield llm.object).actions;
-                    return {
-                        messages: "Hello, world!",
-                        actions: selectedWorkflows,
-                    };
-                }),
-                relationships: [{ name: "actions" }],
-            },
-            actions: {
-                name: "actions",
-                description: "Actions",
-                execute: (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, state.actions, (graph) => {
-                        console.log(`Graph ${graph.name} updated`, graph.getState());
-                    }, (error, nodeName, state) => {
-                        console.error(`Erreur dans ${nodeName}`, error, state);
-                    });
-                    return {
-                        actions: results,
-                    };
-                }),
-                condition: (state) => {
-                    if (state.actions && state.actions.length > 0) {
-                        return true;
-                    }
-                    return false;
-                },
-            },
-        },
-    };
-    const reasoningGraph = new engine_1.GraphEngine(reasoningGraphDefinition);
-    yield reasoningGraph.execute(initialState, "reasoning", (graph) => {
-        console.log("Main graph updated", graph.name);
-        console.dir(graph.getState(), { depth: null });
-    }, (error, nodeName, state) => {
-        console.error(`Erreur dans ${nodeName}`, error, state);
-    });
-}))();

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

@@ -1,142 +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());
-    });
-};
-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);
-    });
-}))();