@ai.ntellect/core 0.4.1 → 0.6.0

package/dist/test/services/agenda.test.js

@@ -0,0 +1,230 @@
+"use strict";
+// import { expect } from "chai";
+// import sinon from "sinon";
+// import { Agenda } from "../../services/agenda";
+// before(function () {
+//   this.timeout(10000);
+// });
+// describe("Agenda Service", () => {
+//   let agenda: Agenda;
+//   const scheduledIds: string[] = []; // Track all scheduled request IDs
+//   beforeEach(() => {
+//     agenda = new Agenda();
+//   });
+//   afterEach(async () => {
+//     // Cancel all scheduled requests by their IDs
+//     scheduledIds.forEach((id) => agenda.cancelScheduledRequest(id));
+//     scheduledIds.length = 0; // Clear the array
+//     // Ensure all tasks are stopped
+//     await agenda.stop();
+//     // Vider la file d'attente
+//     await agenda.cancel({});
+//     // Attendre un peu pour s'assurer que tout est arrêté
+//     await new Promise((resolve) => setTimeout(resolve, 100));
+//   });
+//   describe("Request Scheduling", () => {
+//     it("should schedule a new request and return an id", async () => {
+//       const request = {
+//         originalRequest: "test request",
+//         cronExpression: "0 0 * * *",
+//       };
+//       const id = await agenda.scheduleRequest(request);
+//       scheduledIds.push(id); // Track the ID
+//       expect(id).to.be.a("string");
+//       expect(agenda.getScheduledRequests()).to.have.lengthOf(1);
+//       const scheduledRequest = agenda.getScheduledRequests()[0];
+//       expect(scheduledRequest.originalRequest).to.equal(
+//         request.originalRequest
+//       );
+//       expect(scheduledRequest.cronExpression).to.equal(request.cronExpression);
+//       expect(scheduledRequest.isRecurring).to.be.false;
+//       agenda.cancelScheduledRequest(id);
+//     });
+//     it("should execute callbacks when scheduling and executing", async function () {
+//       this.timeout(5000);
+//       const onScheduledSpy = sinon.spy();
+//       const onExecutedSpy = sinon.spy();
+//       const request = {
+//         originalRequest: "test request",
+//         cronExpression: `${(new Date().getSeconds() + 1) % 60} * * * * *`,
+//       };
+//       const id = await agenda.scheduleRequest(request, {
+//         onScheduled: onScheduledSpy,
+//         onExecuted: onExecutedSpy,
+//       });
+//       scheduledIds.push(id); // Track the ID
+//       expect(onScheduledSpy.calledOnce).to.be.true;
+//       await new Promise<void>((resolve, reject) => {
+//         const timeout = setTimeout(() => {
+//           reject(new Error("Callback execution timeout"));
+//         }, 4000);
+//         const checkExecution = () => {
+//           if (onExecutedSpy.calledOnce) {
+//             clearTimeout(timeout);
+//             agenda.cancelScheduledRequest(id);
+//             resolve();
+//             return;
+//           }
+//           setTimeout(checkExecution, 100);
+//         };
+//         checkExecution();
+//       });
+//       expect(onExecutedSpy.calledOnce).to.be.true;
+//     });
+//   });
+//   describe("Request Management", () => {
+//     it("should cancel a scheduled request", async () => {
+//       const request = {
+//         originalRequest: "test request",
+//         cronExpression: "*/1 * * * *",
+//       };
+//       const id = await agenda.scheduleRequest(request);
+//       scheduledIds.push(id); // Track the ID
+//       expect(agenda.getScheduledRequests()).to.have.lengthOf(1);
+//       const cancelled = agenda.cancelScheduledRequest(id);
+//       expect(cancelled).to.be.true;
+//       expect(agenda.getScheduledRequests()).to.have.lengthOf(0);
+//     });
+//     it("should return false when cancelling non-existent request", () => {
+//       const cancelled = agenda.cancelScheduledRequest("non-existent-id");
+//       expect(cancelled).to.be.false;
+//     });
+//     it("should get all scheduled requests", async () => {
+//       const requests = [
+//         {
+//           originalRequest: "request 1",
+//           cronExpression: "*/1 * * * *",
+//         },
+//         {
+//           originalRequest: "request 2",
+//           cronExpression: "*/5 * * * *",
+//         },
+//       ];
+//       for (const request of requests) {
+//         const id = await agenda.scheduleRequest(request);
+//         scheduledIds.push(id); // Track the ID
+//       }
+//       const scheduledRequests = agenda.getScheduledRequests();
+//       expect(scheduledRequests).to.have.lengthOf(2);
+//       expect(scheduledRequests[0].originalRequest).to.equal("request 1");
+//       expect(scheduledRequests[1].originalRequest).to.equal("request 2");
+//     });
+//   });
+//   describe("Global Management", () => {
+//     it("should stop all scheduled requests", async () => {
+//       const requests = [
+//         {
+//           originalRequest: "request 1",
+//           cronExpression: "*/1 * * * *",
+//         },
+//         {
+//           originalRequest: "request 2",
+//           cronExpression: "*/5 * * * *",
+//         },
+//       ];
+//       for (const request of requests) {
+//         await agenda.scheduleRequest(request);
+//       }
+//       expect(agenda.getScheduledRequests()).to.have.lengthOf(2);
+//       agenda.stopAll();
+//       expect(agenda.getScheduledRequests()).to.have.lengthOf(0);
+//     });
+//   });
+//   describe("Error Handling", () => {
+//     it("should handle execution errors gracefully", async () => {
+//       const consoleSpy = sinon.spy(console, "error");
+//       const request = {
+//         originalRequest: "error request",
+//         cronExpression: "0 0 * * *",
+//       };
+//       const id = await agenda.scheduleRequest(request);
+//       // Wait for execution
+//       await new Promise((resolve) => setTimeout(resolve, 1100));
+//       expect(consoleSpy.called).to.be.false;
+//       agenda.cancelScheduledRequest(id);
+//       consoleSpy.restore();
+//     });
+//   });
+//   describe("Request Execution", () => {
+//     it("should execute non-recurring requests only once", async function () {
+//       this.timeout(5000);
+//       const onExecutedSpy = sinon.spy();
+//       const request = {
+//         originalRequest: "single execution",
+//         cronExpression: `${new Date().getSeconds() + 1} * * * * *`,
+//       };
+//       const id = await agenda.scheduleRequest(request, {
+//         onExecuted: onExecutedSpy,
+//       });
+//       try {
+//         await new Promise<void>((resolve, reject) => {
+//           const timeout = setTimeout(
+//             () => reject(new Error("Test timeout")),
+//             4000
+//           );
+//           const checkExecution = () => {
+//             if (onExecutedSpy.calledOnce) {
+//               clearTimeout(timeout);
+//               resolve();
+//               return;
+//             }
+//             setTimeout(checkExecution, 100);
+//           };
+//           checkExecution();
+//         });
+//       } finally {
+//         agenda.cancelScheduledRequest(id);
+//       }
+//       expect(onExecutedSpy.calledOnce).to.be.true;
+//       expect(agenda.getScheduledRequests()).to.have.lengthOf(0);
+//     });
+//     it("should log execution status", async function () {
+//       this.timeout(10000);
+//       const consoleLogSpy = sinon.spy(console, "log");
+//       const request = {
+//         originalRequest: "test request",
+//         cronExpression: `${new Date().getSeconds() + 1} * * * * *`,
+//       };
+//       const id = await agenda.scheduleRequest(request);
+//       await new Promise<void>((resolve) => {
+//         const checkExecution = () => {
+//           if (
+//             consoleLogSpy.calledWith(`🔄 Executing scheduled request: ${id}`) &&
+//             consoleLogSpy.calledWith(
+//               `✅ Scheduled request executed successfully: ${id}`
+//             )
+//           ) {
+//             agenda.cancelScheduledRequest(id);
+//             resolve();
+//             return;
+//           }
+//           setTimeout(checkExecution, 100);
+//         };
+//         checkExecution();
+//       });
+//       expect(consoleLogSpy.calledWith(`🔄 Executing scheduled request: ${id}`))
+//         .to.be.true;
+//       expect(
+//         consoleLogSpy.calledWith(
+//           `✅ Scheduled request executed successfully: ${id}`
+//         )
+//       ).to.be.true;
+//       consoleLogSpy.restore();
+//     });
+//   });
+// });
+// // Déplacer la variable agenda en dehors du describe pour la rendre accessible
+// let globalAgenda: Agenda;
+// before(() => {
+//   globalAgenda = new Agenda();
+// });
+// after(async () => {
+//   if (globalAgenda) {
+//     globalAgenda.stopAll();
+//     await new Promise((resolve) => setTimeout(resolve, 100));
+//   }
+//   // Nettoyage final
+//   await globalAgenda.stop();
+//   await globalAgenda.cancel({});
+//   await new Promise((resolve) => setTimeout(resolve, 100));
+// });

package/dist/test/services/queue.test.js

@@ -0,0 +1,258 @@
+"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 queue_1 = require("@/services/queue");
+const chai_1 = require("chai");
+const zod_1 = require("zod");
+describe("Queue", () => {
+    // Test actions setup
+    const testActions = [
+        {
+            name: "action1",
+            description: "Test action 1",
+            parameters: zod_1.z.object({}),
+            execute: (params) => __awaiter(void 0, void 0, void 0, function* () { return ({ success: true, params }); }),
+        },
+        {
+            name: "action2",
+            description: "Test action 2",
+            parameters: zod_1.z.object({}),
+            execute: (params) => __awaiter(void 0, void 0, void 0, function* () { return ({ success: true, params }); }),
+            confirmation: {
+                requireConfirmation: true,
+                message: "Confirm action2?",
+            },
+        },
+        {
+            name: "actionWithError",
+            description: "Test error action",
+            parameters: zod_1.z.object({}),
+            execute: () => __awaiter(void 0, void 0, void 0, function* () {
+                throw new Error("Test error");
+            }),
+        },
+    ];
+    let queue;
+    let callbacks;
+    beforeEach(() => {
+        // Reset callbacks for each test
+        callbacks = {
+            onActionStart: () => { },
+            onActionComplete: () => { },
+            onQueueComplete: () => { },
+            onConfirmationRequired: () => __awaiter(void 0, void 0, void 0, function* () { return true; }),
+        };
+        queue = new queue_1.Queue(testActions, callbacks);
+    });
+    describe("Queue Management", () => {
+        it("should add a single action to the queue", () => {
+            const action = {
+                name: "action1",
+                parameters: [{ name: "param1", value: "value1" }],
+            };
+            queue.add(action);
+            (0, chai_1.expect)(queue["queue"]).to.have.lengthOf(1);
+            (0, chai_1.expect)(queue["queue"][0]).to.deep.equal(action);
+        });
+        it("should add multiple actions to the queue", () => {
+            const actions = [
+                {
+                    name: "action1",
+                    parameters: [{ name: "param1", value: "value1" }],
+                },
+                {
+                    name: "action2",
+                    parameters: [{ name: "param2", value: "value2" }],
+                },
+            ];
+            queue.add(actions);
+            (0, chai_1.expect)(queue["queue"]).to.have.lengthOf(2);
+            (0, chai_1.expect)(queue["queue"]).to.deep.equal(actions);
+        });
+    });
+    describe("Action Execution", () => {
+        it("should execute a single action successfully", () => __awaiter(void 0, void 0, void 0, function* () {
+            const action = {
+                name: "action1",
+                parameters: [{ name: "param1", value: "value1" }],
+            };
+            queue.add(action);
+            const results = yield queue.execute();
+            if (!results) {
+                throw new Error("Results are undefined");
+            }
+            (0, chai_1.expect)(results).to.not.be.undefined;
+            (0, chai_1.expect)(results).to.have.lengthOf(1);
+            (0, chai_1.expect)(results[0].name).to.equal("action1");
+            (0, chai_1.expect)(results[0].error).to.be.null;
+            (0, chai_1.expect)(results[0].result).to.deep.include({ success: true });
+        }));
+        it("should handle action execution errors", () => __awaiter(void 0, void 0, void 0, function* () {
+            const action = {
+                name: "actionWithError",
+                parameters: [],
+            };
+            queue.add(action);
+            const results = yield queue.execute();
+            if (!results) {
+                throw new Error("Results are undefined");
+            }
+            (0, chai_1.expect)(results).to.not.be.undefined;
+            (0, chai_1.expect)(results).to.have.lengthOf(1);
+            (0, chai_1.expect)(results[0].name).to.equal("actionWithError");
+            (0, chai_1.expect)(results[0].error).to.equal("Test error");
+            (0, chai_1.expect)(results[0].result).to.be.null;
+        }));
+        it("should respect confirmation requirements", () => __awaiter(void 0, void 0, void 0, function* () {
+            let confirmationCalled = false;
+            callbacks.onConfirmationRequired = () => __awaiter(void 0, void 0, void 0, function* () {
+                confirmationCalled = true;
+                return false; // Reject the confirmation
+            });
+            queue = new queue_1.Queue(testActions, callbacks);
+            const action = {
+                name: "action2", // Action requiring confirmation
+                parameters: [],
+            };
+            queue.add(action);
+            const results = yield queue.execute();
+            if (!results) {
+                throw new Error("Results are undefined");
+            }
+            (0, chai_1.expect)(results).to.not.be.undefined;
+            (0, chai_1.expect)(confirmationCalled).to.be.true;
+            (0, chai_1.expect)(results[0].cancelled).to.be.true;
+            (0, chai_1.expect)(results[0].error).to.equal("Action cancelled by user");
+        }));
+    });
+    describe("Parameter Handling", () => {
+        it("should correctly format simple parameters", () => __awaiter(void 0, void 0, void 0, function* () {
+            const action = {
+                name: "action1",
+                parameters: [
+                    { name: "param1", value: "value1" },
+                    { name: "param2", value: "value2" },
+                ],
+            };
+            queue.add(action);
+            const results = yield queue.execute();
+            if (!results) {
+                throw new Error("Results are undefined");
+            }
+            (0, chai_1.expect)(results).to.not.be.undefined;
+            (0, chai_1.expect)(results[0].parameters).to.deep.equal({
+                param1: "value1",
+                param2: "value2",
+            });
+        }));
+        it("should handle JSON stringified parameters", () => __awaiter(void 0, void 0, void 0, function* () {
+            const action = {
+                name: "action1",
+                parameters: [
+                    {
+                        name: "jsonParam",
+                        value: JSON.stringify({ name: "test", value: "value" }),
+                    },
+                ],
+            };
+            queue.add(action);
+            const results = yield queue.execute();
+            if (!results) {
+                throw new Error("Results are undefined");
+            }
+            (0, chai_1.expect)(results).to.not.be.undefined;
+            (0, chai_1.expect)(results[0].parameters).to.deep.equal({
+                test: "value",
+            });
+        }));
+    });
+    describe("Queue Processing State", () => {
+        it("should prevent concurrent queue processing", () => __awaiter(void 0, void 0, void 0, function* () {
+            const action = {
+                name: "action1",
+                parameters: [],
+            };
+            queue.add(action);
+            // Start first execution
+            const firstExecution = queue.execute();
+            // Try to execute again while first execution is running
+            const secondExecution = queue.execute();
+            const [firstResults, secondResults] = yield Promise.all([
+                firstExecution,
+                secondExecution,
+            ]);
+            (0, chai_1.expect)(firstResults).to.not.be.undefined;
+            (0, chai_1.expect)(firstResults).to.have.lengthOf(1);
+            (0, chai_1.expect)(secondResults).to.be.undefined;
+        }));
+        it("should reset processing state after completion", () => __awaiter(void 0, void 0, void 0, function* () {
+            const action = {
+                name: "action1",
+                parameters: [],
+            };
+            queue.add(action);
+            const results = yield queue.execute();
+            if (!results) {
+                throw new Error("Results are undefined");
+            }
+            (0, chai_1.expect)(results).to.have.lengthOf(1);
+            // Verify that isProcessing is reset
+            (0, chai_1.expect)(queue["isProcessing"]).to.be.false;
+            // Clear both queue and results before adding new action
+            queue["queue"] = [];
+            queue["results"] = [];
+            // Should be able to execute again
+            queue.add(action);
+            const secondResults = yield queue.execute();
+            if (!secondResults) {
+                throw new Error("Second results are undefined");
+            }
+            (0, chai_1.expect)(secondResults).to.have.lengthOf(1);
+        }));
+    });
+    describe("Callback Handling", () => {
+        it("should trigger all callbacks in correct order", () => __awaiter(void 0, void 0, void 0, function* () {
+            const callbackOrder = [];
+            callbacks = {
+                onActionStart: () => callbackOrder.push("start"),
+                onActionComplete: () => callbackOrder.push("complete"),
+                onQueueComplete: () => callbackOrder.push("queueComplete"),
+            };
+            queue = new queue_1.Queue(testActions, callbacks);
+            const action = {
+                name: "action1",
+                parameters: [],
+            };
+            queue.add(action);
+            yield queue.execute();
+            (0, chai_1.expect)(callbackOrder).to.deep.equal([
+                "start",
+                "complete",
+                "queueComplete",
+            ]);
+        }));
+        it("should handle missing callbacks gracefully", () => __awaiter(void 0, void 0, void 0, function* () {
+            queue = new queue_1.Queue(testActions, {}); // No callbacks provided
+            const action = {
+                name: "action1",
+                parameters: [],
+            };
+            queue.add(action);
+            const results = yield queue.execute();
+            if (!results) {
+                throw new Error("Results are undefined");
+            }
+            (0, chai_1.expect)(results).to.not.be.undefined;
+            (0, chai_1.expect)(results).to.have.lengthOf(1);
+            (0, chai_1.expect)(results[0].error).to.be.null;
+        }));
+    });
+});

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/generate-object.js

@@ -1,4 +1,13 @@
 "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.generateObject = exports.describeZodSchema = void 0;
 const ai_1 = require("ai");
@@ -44,14 +53,12 @@ const describeZodSchema = (schema) => {
     return "z.unknown()"; // Fallback for unknown types
 };
 exports.describeZodSchema = describeZodSchema;
-const generateObject = async (config) => {
+const generateObject = (config) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
     // Generate a detailed description of the schema
     const schemaDescription = (0, exports.describeZodSchema)(config.schema);
-    console.log("🔍 Schema Description:\n", schemaDescription);
-    const response = await (0, ai_1.generateText)({
-        model: config.model,
-        prompt: `${config.prompt}
-  
+    const baseContext = `
+  ${config.system}
   EXPECTED SCHEMA:
   ${schemaDescription}
   
@@ -61,16 +68,30 @@ const generateObject = async (config) => {
     "key": "value"
   }
   \`\`\`
-  
+
   GOOD EXAMPLE:
   {
     "key": "value"
   }
-  
-  Output only the JSON schema, no 'triple quotes'json or any other text. Only the JSON schema.
-  `,
+
+  OUTPUT ONLY THE JSON SCHEMA, NO 'TRIPLE QUOTES'JSON OR ANY OTHER TEXT. ONLY THE JSON SCHEMA.
+  `;
+    console.log("🔍 Generating object with context:");
+    console.log(`${config.prompt}\n${baseContext}\n`);
+    const response = yield (0, ai_1.generateText)({
+        model: config.model,
+        messages: !config.prompt
+            ? [
+                {
+                    role: "system",
+                    content: baseContext,
+                },
+                ...((_a = config.messages) !== null && _a !== void 0 ? _a : []),
+            ]
+            : undefined,
         system: config.system,
         temperature: config.temperature,
+        prompt: !config.prompt ? undefined : `${config.prompt}\n\n${baseContext}`,
     });
     try {
         // Clean the response text from any markdown or code block markers
@@ -86,5 +107,5 @@ const generateObject = async (config) => {
         console.error("Error parsing or validating JSON response:", error);
         throw new Error("Failed to generate valid JSON response");
     }
-};
+});
 exports.generateObject = generateObject;

package/dist/utils/inject-actions.js

@@ -5,8 +5,8 @@ const injectActions = (actions) => {
     return actions.map((action) => {
         const parameters = action.parameters;
         const schemaShape = Object.keys(parameters._def.shape()).join(", ");
-        const actionString = `Name: ${action.name}, Description: ${action.description}, Arguments: { ${schemaShape} } ${action.examples
-            ? `Format examples: ${action.examples.map((example) => {
+        const actionString = `* ${action.name}( { ${schemaShape} }) (${action.description}) ${action.examples
+            ? `Eg: ${action.examples.map((example) => {
                 return JSON.stringify(example);
             })}`
             : ""}`;

package/dist/utils/queue-item-transformer.js

@@ -9,7 +9,7 @@ class QueueItemTransformer {
         };
     }
     static transformFromSimilarActions(similarActions) {
-        return similarActions?.map((action) => QueueItemTransformer.transformActionToQueueItem(action));
+        return similarActions === null || similarActions === void 0 ? void 0 : similarActions.map((action) => QueueItemTransformer.transformActionToQueueItem(action));
     }
     static transformParameters(parameters) {
         return Object.entries(parameters).map(([name, value]) => ({
@@ -18,7 +18,7 @@ class QueueItemTransformer {
         }));
     }
     static transformActionsToQueueItems(actions) {
-        return actions?.map((action) => this.transformActionToQueueItem(action));
+        return actions === null || actions === void 0 ? void 0 : actions.map((action) => this.transformActionToQueueItem(action));
     }
 }
 exports.QueueItemTransformer = QueueItemTransformer;

package/dist/utils/state-manager.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateManager = void 0;
+class StateManager {
+    /**
+     * Updates the shared state while preserving immutability
+     * @param currentState Current shared state
+     * @param updates Partial updates to apply
+     * @returns Updated shared state
+     */
+    static updateState(state, updates) {
+        return Object.assign(Object.assign({}, state), { context: Object.assign(Object.assign({}, (state.context || {})), updates) });
+    }
+    static createUpdate(updates) {
+        return {
+            context: Object.assign({}, updates),
+        };
+    }
+}
+exports.StateManager = StateManager;

package/graph/controller.ts

@@ -0,0 +1,60 @@
+import { GraphDefinition } from "@/types";
+import { GraphEngine } from "./engine";
+
+/**
+ * Controller responsible for executing workflows based on graph definitions.
+ * @template T The type representing the graph's state.
+ */
+export class GraphController<T> {
+  /**
+   * 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.
+   */
+  async run(actions: any[], graphs: GraphDefinition<T>[]): Promise<any> {
+    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 GraphEngine(graphDefinition, {
+        schema: graphDefinition.schema,
+        autoDetectCycles: true,
+      });
+
+      // Construct the initial state from action parameters.
+      const initialState = {
+        context: action.parameters.reduce(
+          (acc: Record<string, any>, param: { name: string; value: any }) => {
+            acc[param.name] = param.value;
+            return acc;
+          },
+          {}
+        ),
+      };
+
+      // Execute the graph starting from the defined entry node.
+      await 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;
+    }
+  }
+}