@ai.ntellect/core 0.6.0 → 0.6.2

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.