@receptron/graphai_express 0.0.26 → 0.0.28

package/README.md

@@ -13,27 +13,38 @@ yarn add @receptron/graphai_express
 
 import express from "express";
 import * as agents from "@graphai/agents";
-import { agentDispatcher, nonStreamAgentDispatcher, streamAgentDispatcher, agentsList, agentDoc } from "@receptron/graphai_express";
+import { agentDispatcher, nonStreamAgentDispatcher, streamAgentDispatcher, agentsList, agentDoc, graphRunner} from "@receptron/graphai_express";
 import { AgentFunctionInfoDictionary } from "graphai";
 
 const agentDictionary: AgentFunctionInfoDictionary = agents;
 const hostName = "https://example.net";
-const apiPrefix = "/api/agents";
+const apiAgentPrefix = "/api/agents";
+const apiGraphPrefix = "/api/graph";
 
-app.get(apiPrefix + "/:agentId", agentDoc(agentDictionary, hostName, apiPrefix)); // each API(agent) document
-app.get(apiPrefix + "/", agentsList(agentDictionary, hostName, apiPrefix));  // API(agent) list
+app.get(apiAgentPrefix + "/:agentId", agentDoc(agentDictionary, hostName, apiAgentPrefix)); // each API(agent) document
+app.get(apiAgentPrefix + "/", agentsList(agentDictionary, hostName, apiAgentPrefix));  // API(agent) list
 
-// non stream and strwam
-app.post(apiPrefix + "/:agentId", agentDispatcher(agentDictionary));
+// non stream and stream agent server
+app.post(apiAgentPrefix + "/:agentId", agentDispatcher(agentDictionary));
 
-//  non stream
-app.post(apiPrefix + "/nonstream/:agentId", nonStreamAgentDispatcher(agentDictionary));
+// non stream agent server
+app.post(apiAgentPrefix + "/nonstream/:agentId", nonStreamAgentDispatcher(agentDictionary));
+
+// stream agent server
+app.post(apiAgentPrefix + "/stream/:agentId", streamAgentDispatcher(agentDictionary));
+
+// non stream and stream agent server
+app.post(apiGraphPrefix + "/", graphRunner(agentDictionary));
 
-//  stream
-app.post(apiPrefix + "/stream/:agentId", streamAgentDispatcher(agentDictionary));
 
 ```
 
+### Run Test server
+
+```
+yarn run server
+```
+
 
 ### Test from curl
 
@@ -43,8 +54,9 @@ curl -X POST -H "Content-Type: application/json" -d '{"params": {"message" : "he
 
 ### from GraphAI Client
 
-T.B.D.
-
+```
+npx ts-node  test/stream_graph.ts
+```
 
 ### for this middleware development
 

package/lib/agents.d.ts

@@ -0,0 +1,9 @@
+import express from "express";
+import type { AgentFunctionInfoDictionary, AgentFilterInfo } from "graphai";
+import { StreamChunkCallback } from "./type";
+export declare const agentsList: (agentDictionary: AgentFunctionInfoDictionary, hostName?: string, urlPath?: string) => (req: express.Request, res: express.Response) => Promise<void>;
+export declare const agentDoc: (agentDictionary: AgentFunctionInfoDictionary, hostName?: string, urlPath?: string) => (req: express.Request, res: express.Response) => Promise<void>;
+export declare const agentDispatcher: (agentDictionary: AgentFunctionInfoDictionary, agentFilters?: AgentFilterInfo[], streamChunkCallback?: StreamChunkCallback) => (req: express.Request, res: express.Response, next: express.NextFunction) => Promise<express.Response<any, Record<string, any>> | undefined>;
+export declare const agentRunner: (agentDictionary: AgentFunctionInfoDictionary, agentFilters?: AgentFilterInfo[], streamChunkCallback?: StreamChunkCallback) => (req: express.Request, res: express.Response, next: express.NextFunction) => Promise<express.Response<any, Record<string, any>> | undefined>;
+export declare const nonStreamAgentDispatcher: (agentDictionary: AgentFunctionInfoDictionary, agentFilters?: AgentFilterInfo[], isDispatch?: boolean) => (req: express.Request, res: express.Response, next: express.NextFunction) => Promise<express.Response<any, Record<string, any>> | undefined>;
+export declare const streamAgentDispatcher: (agentDictionary: AgentFunctionInfoDictionary, agentFilters?: AgentFilterInfo[], isDispatch?: boolean, streamChunkCallback?: StreamChunkCallback) => (req: express.Request, res: express.Response, next: express.NextFunction) => Promise<express.Response<any, Record<string, any>> | undefined>;

package/lib/agents.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamAgentDispatcher = exports.nonStreamAgentDispatcher = exports.agentRunner = exports.agentDispatcher = exports.agentDoc = exports.agentsList = void 0;
+const agent_filters_1 = require("@graphai/agent_filters");
+// express middleware
+// return agent list
+const agentsList = (agentDictionary, hostName = "https://example.com", urlPath = "/agent") => {
+    return async (req, res) => {
+        const list = Object.keys(agentDictionary).map((agentName) => {
+            const agent = agentDictionary[agentName];
+            return {
+                agentId: agentName,
+                name: agent.name,
+                url: hostName + urlPath + "/" + agentName,
+                description: agent.description,
+                category: agent.category,
+                author: agent.author,
+                license: agent.license,
+                repository: agent.repository,
+                samples: agent.samples,
+                inputs: agent.inputs,
+                output: agent.output,
+                stream: agent.stream ?? false,
+            };
+        });
+        res.json({ agents: list });
+    };
+};
+exports.agentsList = agentsList;
+// express middleware
+// return agent detail info
+const agentDoc = (agentDictionary, hostName = "https://example.com", urlPath = "/agent") => {
+    return async (req, res) => {
+        const { params } = req;
+        const { agentId } = params;
+        const agent = agentDictionary[agentId];
+        if (agent === undefined) {
+            res.status(404).send("Not found");
+            return;
+        }
+        const result = {
+            agentId: agentId,
+            name: agent.name,
+            url: hostName + urlPath + "/" + agentId,
+            description: agent.description,
+            category: agent.category,
+            samples: agent.samples,
+            author: agent.author,
+            license: agent.license,
+            repository: agent.repository,
+        };
+        res.json(result);
+    };
+};
+exports.agentDoc = agentDoc;
+// express middleware
+// dispatch and run agent
+// app.post(apiPrefix + "/:agentId", agentDispatcher(agentDictionary));
+const agentDispatcher = (agentDictionary, agentFilters = [], streamChunkCallback) => {
+    const nonStram = (0, exports.nonStreamAgentDispatcher)(agentDictionary, agentFilters, true);
+    const stream = (0, exports.streamAgentDispatcher)(agentDictionary, agentFilters, true, streamChunkCallback);
+    return async (req, res, next) => {
+        const isStreaming = (req.headers["content-type"] || "").startsWith("text/event-stream");
+        if (isStreaming) {
+            return await stream(req, res, next);
+        }
+        return await nonStram(req, res, next);
+    };
+};
+exports.agentDispatcher = agentDispatcher;
+// express middleware
+// run agent
+// app.post(agentPrefix, agentRunner(agentDictionary));
+const agentRunner = (agentDictionary, agentFilters = [], streamChunkCallback) => {
+    const nonStram = (0, exports.nonStreamAgentDispatcher)(agentDictionary, agentFilters, false);
+    const stream = (0, exports.streamAgentDispatcher)(agentDictionary, agentFilters, false, streamChunkCallback);
+    return async (req, res, next) => {
+        const isStreaming = (req.headers["content-type"] || "").startsWith("text/event-stream");
+        if (isStreaming) {
+            return await stream(req, res, next);
+        }
+        return await nonStram(req, res, next);
+    };
+};
+exports.agentRunner = agentRunner;
+// express middleware
+// run agent
+const nonStreamAgentDispatcher = (agentDictionary, agentFilters = [], isDispatch = true) => {
+    return async (req, res, next) => {
+        try {
+            const dispatcher = agentDispatcherInternal(agentDictionary, agentFilters, isDispatch);
+            const result = await dispatcher(req, res);
+            return res.json(result);
+        }
+        catch (e) {
+            next(e);
+        }
+    };
+};
+exports.nonStreamAgentDispatcher = nonStreamAgentDispatcher;
+// express middleware
+// run agent with streaming
+const streamAgentDispatcher = (agentDictionary, agentFilters = [], isDispatch = true, streamChunkCallback) => {
+    return async (req, res, next) => {
+        try {
+            res.setHeader("Content-Type", "text/event-stream;charset=utf-8");
+            res.setHeader("Cache-Control", "no-cache, no-transform");
+            res.setHeader("X-Accel-Buffering", "no");
+            const callback = (context, token) => {
+                if (token) {
+                    if (streamChunkCallback) {
+                        res.write(streamChunkCallback(context, token));
+                    }
+                    else {
+                        res.write(token);
+                    }
+                }
+            };
+            const streamAgentFilter = {
+                name: "streamAgentFilter",
+                agent: (0, agent_filters_1.streamAgentFilterGenerator)(callback),
+            };
+            const filterList = [...agentFilters, streamAgentFilter];
+            const dispatcher = agentDispatcherInternal(agentDictionary, filterList, isDispatch);
+            const result = await dispatcher(req, res);
+            const json_data = JSON.stringify(result);
+            res.write("___END___");
+            res.write(json_data);
+            return res.end();
+        }
+        catch (e) {
+            next(e);
+        }
+    };
+};
+exports.streamAgentDispatcher = streamAgentDispatcher;
+// dispatcher internal function
+const agentDispatcherInternal = (agentDictionary, agentFilters = [], isDispatch = true) => {
+    return async (req, res) => {
+        const { params } = req;
+        const { agentId } = isDispatch ? params : req.body;
+        const { nodeId, retry, params: agentParams, inputs, namedInputs } = req.body;
+        const agent = agentDictionary[agentId];
+        if (agent === undefined) {
+            res.status(404).send("Not found");
+            return;
+        }
+        const context = {
+            params: agentParams || {},
+            inputs,
+            namedInputs,
+            debugInfo: {
+                nodeId,
+                retry,
+                verbose: false,
+            },
+            agents: agentDictionary,
+            filterParams: {},
+        };
+        const agentFilterRunner = (0, agent_filters_1.agentFilterRunnerBuilder)(agentFilters);
+        const result = await agentFilterRunner(context, agent.agent);
+        return result;
+    };
+};

package/lib/graph.d.ts

@@ -0,0 +1,6 @@
+import express from "express";
+import type { AgentFunctionInfoDictionary, AgentFilterInfo } from "graphai";
+import { StreamChunkCallback } from "./type";
+export declare const graphRunner: (agentDictionary: AgentFunctionInfoDictionary, agentFilters?: AgentFilterInfo[], streamChunkCallback?: StreamChunkCallback) => (req: express.Request, res: express.Response, next: express.NextFunction) => Promise<express.Response<any, Record<string, any>> | undefined>;
+export declare const streamGraphRunner: (agentDictionary: AgentFunctionInfoDictionary, agentFilters?: AgentFilterInfo[], streamChunkCallback?: StreamChunkCallback) => (req: express.Request, res: express.Response, next: express.NextFunction) => Promise<express.Response<any, Record<string, any>> | undefined>;
+export declare const nonStreamGraphRunner: (agentDictionary: AgentFunctionInfoDictionary, agentFilters?: AgentFilterInfo[]) => (req: express.Request, res: express.Response, next: express.NextFunction) => Promise<express.Response<any, Record<string, any>> | undefined>;

package/lib/graph.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nonStreamGraphRunner = exports.streamGraphRunner = exports.graphRunner = void 0;
+const graphai_1 = require("graphai");
+const agent_filters_1 = require("@graphai/agent_filters");
+const graphRunner = (agentDictionary, agentFilters = [], streamChunkCallback) => {
+    const stream = (0, exports.streamGraphRunner)(agentDictionary, agentFilters, streamChunkCallback);
+    const nonStream = (0, exports.nonStreamGraphRunner)(agentDictionary, agentFilters);
+    return async (req, res, next) => {
+        const isStreaming = (req.headers["content-type"] || "").startsWith("text/event-stream");
+        if (isStreaming) {
+            return await stream(req, res, next);
+        }
+        return await nonStream(req, res, next);
+    };
+};
+exports.graphRunner = graphRunner;
+const streamGraphRunner = (agentDictionary, agentFilters = [], streamChunkCallback) => {
+    return async (req, res, next) => {
+        try {
+            res.setHeader("Content-Type", "text/event-stream;charset=utf-8");
+            res.setHeader("Cache-Control", "no-cache, no-transform");
+            res.setHeader("X-Accel-Buffering", "no");
+            const streamCallback = (context, token) => {
+                if (token) {
+                    if (streamChunkCallback) {
+                        res.write(streamChunkCallback(context, token));
+                    }
+                    else {
+                        res.write(token);
+                    }
+                }
+            };
+            const streamAgentFilter = {
+                name: "streamAgentFilter",
+                agent: (0, agent_filters_1.streamAgentFilterGenerator)(streamCallback),
+            };
+            const filterList = [...agentFilters, streamAgentFilter];
+            const dispatcher = streamGraphRunnerInternal(agentDictionary, filterList);
+            const result = await dispatcher(req, res);
+            const json_data = JSON.stringify(result);
+            res.write("___END___");
+            res.write(json_data);
+            return res.end();
+        }
+        catch (e) {
+            next(e);
+        }
+    };
+};
+exports.streamGraphRunner = streamGraphRunner;
+const nonStreamGraphRunner = (agentDictionary, agentFilters = []) => {
+    return async (req, res, next) => {
+        try {
+            const dispatcher = streamGraphRunnerInternal(agentDictionary, agentFilters);
+            const result = await dispatcher(req, res);
+            return res.json(result);
+        }
+        catch (e) {
+            next(e);
+        }
+    };
+};
+exports.nonStreamGraphRunner = nonStreamGraphRunner;
+// internal function
+const streamGraphRunnerInternal = (agentDictionary, agentFilters = []) => {
+    return async (req, res) => {
+        const { graphData } = req.body;
+        const { config } = req;
+        const graphai = new graphai_1.GraphAI(graphData, agentDictionary, { agentFilters, config: config ?? {} });
+        const result = await graphai.run(true);
+        return result;
+    };
+};

package/lib/index.d.ts

@@ -1,10 +1,3 @@
-import express from "express";
-import type { AgentFunctionInfoDictionary, AgentFilterInfo } from "graphai";
-import { ExpressAgentInfo } from "./type";
-export { ExpressAgentInfo };
-export declare const agentsList: (agentDictionary: AgentFunctionInfoDictionary, hostName?: string, urlPath?: string) => (req: express.Request, res: express.Response) => Promise<void>;
-export declare const agentDoc: (agentDictionary: AgentFunctionInfoDictionary, hostName?: string, urlPath?: string) => (req: express.Request, res: express.Response) => Promise<void>;
-export declare const agentDispatcher: (agentDictionary: AgentFunctionInfoDictionary, agentFilters?: AgentFilterInfo[]) => (req: express.Request, res: express.Response, next: express.NextFunction) => Promise<express.Response<any, Record<string, any>> | undefined>;
-export declare const agentRunner: (agentDictionary: AgentFunctionInfoDictionary, agentFilters?: AgentFilterInfo[]) => (req: express.Request, res: express.Response, next: express.NextFunction) => Promise<express.Response<any, Record<string, any>> | undefined>;
-export declare const nonStreamAgentDispatcher: (agentDictionary: AgentFunctionInfoDictionary, agentFilters?: AgentFilterInfo[], isDispatch?: boolean) => (req: express.Request, res: express.Response, next: express.NextFunction) => Promise<express.Response<any, Record<string, any>> | undefined>;
-export declare const streamAgentDispatcher: (agentDictionary: AgentFunctionInfoDictionary, agentFilters?: AgentFilterInfo[], isDispatch?: boolean) => (req: express.Request, res: express.Response, next: express.NextFunction) => Promise<express.Response<any, Record<string, any>> | undefined>;
+export { agentsList, agentDoc, agentDispatcher, agentRunner, nonStreamAgentDispatcher, streamAgentDispatcher } from "./agents";
+export { graphRunner, streamGraphRunner, nonStreamGraphRunner } from "./graph";
+export { ExpressAgentInfo } from "./type";

package/lib/index.js

@@ -1,159 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.streamAgentDispatcher = exports.nonStreamAgentDispatcher = exports.agentRunner = exports.agentDispatcher = exports.agentDoc = exports.agentsList = void 0;
-const agent_filters_1 = require("@graphai/agent_filters");
-// express middleware
-// return agent list
-const agentsList = (agentDictionary, hostName = "https://example.com", urlPath = "/agent") => {
-    return async (req, res) => {
-        const list = Object.keys(agentDictionary).map((agentName) => {
-            const agent = agentDictionary[agentName];
-            return {
-                agentId: agentName,
-                name: agent.name,
-                url: hostName + urlPath + "/" + agentName,
-                description: agent.description,
-                category: agent.category,
-                author: agent.author,
-                license: agent.license,
-                repository: agent.repository,
-                samples: agent.samples,
-                inputs: agent.inputs,
-                output: agent.output,
-                stream: agent.stream ?? false,
-            };
-        });
-        res.json({ agents: list });
-    };
-};
-exports.agentsList = agentsList;
-// express middleware
-// return agent detail info
-const agentDoc = (agentDictionary, hostName = "https://example.com", urlPath = "/agent") => {
-    return async (req, res) => {
-        const { params } = req;
-        const { agentId } = params;
-        const agent = agentDictionary[agentId];
-        if (agent === undefined) {
-            res.status(404).send("Not found");
-            return;
-        }
-        const result = {
-            agentId: agentId,
-            name: agent.name,
-            url: hostName + urlPath + "/" + agentId,
-            description: agent.description,
-            category: agent.category,
-            samples: agent.samples,
-            author: agent.author,
-            license: agent.license,
-            repository: agent.repository,
-        };
-        res.json(result);
-    };
-};
-exports.agentDoc = agentDoc;
-// express middleware
-// dispatch and run agent
-// app.post(apiPrefix + "/:agentId", agentDispatcher(agentDictionary));
-const agentDispatcher = (agentDictionary, agentFilters = []) => {
-    const nonStram = (0, exports.nonStreamAgentDispatcher)(agentDictionary, agentFilters, true);
-    const stream = (0, exports.streamAgentDispatcher)(agentDictionary, agentFilters, true);
-    return async (req, res, next) => {
-        const isStreaming = (req.headers["content-type"] || "").startsWith("text/event-stream");
-        if (isStreaming) {
-            return await stream(req, res, next);
-        }
-        return await nonStram(req, res, next);
-    };
-};
-exports.agentDispatcher = agentDispatcher;
-// express middleware
-// run agent
-// app.post(agentPrefix, agentRunner(agentDictionary));
-const agentRunner = (agentDictionary, agentFilters = []) => {
-    const nonStram = (0, exports.nonStreamAgentDispatcher)(agentDictionary, agentFilters, false);
-    const stream = (0, exports.streamAgentDispatcher)(agentDictionary, agentFilters, false);
-    return async (req, res, next) => {
-        const isStreaming = (req.headers["content-type"] || "").startsWith("text/event-stream");
-        if (isStreaming) {
-            return await stream(req, res, next);
-        }
-        return await nonStram(req, res, next);
-    };
-};
-exports.agentRunner = agentRunner;
-// express middleware
-// run agent
-const nonStreamAgentDispatcher = (agentDictionary, agentFilters = [], isDispatch = true) => {
-    return async (req, res, next) => {
-        try {
-            const dispatcher = agentDispatcherInternal(agentDictionary, agentFilters, isDispatch);
-            const result = await dispatcher(req, res);
-            return res.json(result);
-        }
-        catch (e) {
-            next(e);
-        }
-    };
-};
-exports.nonStreamAgentDispatcher = nonStreamAgentDispatcher;
-// express middleware
-// run agent with streaming
-const streamAgentDispatcher = (agentDictionary, agentFilters = [], isDispatch = true) => {
-    return async (req, res, next) => {
-        try {
-            res.setHeader("Content-Type", "text/event-stream;charset=utf-8");
-            res.setHeader("Cache-Control", "no-cache, no-transform");
-            res.setHeader("X-Accel-Buffering", "no");
-            const callback = (context, token) => {
-                if (token) {
-                    res.write(token);
-                }
-            };
-            const streamAgentFilter = {
-                name: "streamAgentFilter",
-                agent: (0, agent_filters_1.streamAgentFilterGenerator)(callback),
-            };
-            const filterList = [...agentFilters, streamAgentFilter];
-            const dispatcher = agentDispatcherInternal(agentDictionary, filterList, isDispatch);
-            const result = await dispatcher(req, res);
-            const json_data = JSON.stringify(result);
-            res.write("___END___");
-            res.write(json_data);
-            return res.end();
-        }
-        catch (e) {
-            next(e);
-        }
-    };
-};
-exports.streamAgentDispatcher = streamAgentDispatcher;
-// dispatcher internal function
-const agentDispatcherInternal = (agentDictionary, agentFilters = [], isDispatch = true) => {
-    return async (req, res) => {
-        const { params } = req;
-        const { agentId } = isDispatch ? params : req.body;
-        const { nodeId, retry, params: agentParams, inputs, namedInputs } = req.body;
-        const agent = agentDictionary[agentId];
-        if (agent === undefined) {
-            res.status(404).send("Not found");
-            return;
-        }
-        const context = {
-            params: agentParams || {},
-            inputs,
-            namedInputs,
-            debugInfo: {
-                nodeId,
-                retry,
-                verbose: false,
-            },
-            agents: agentDictionary,
-            filterParams: {},
-        };
-        const agentFilterRunner = (0, agent_filters_1.agentFilterRunnerBuilder)(agentFilters);
-        const result = await agentFilterRunner(context, agent.agent);
-        return result;
-    };
-};
+exports.nonStreamGraphRunner = exports.streamGraphRunner = exports.graphRunner = exports.streamAgentDispatcher = exports.nonStreamAgentDispatcher = exports.agentRunner = exports.agentDispatcher = exports.agentDoc = exports.agentsList = void 0;
+var agents_1 = require("./agents");
+Object.defineProperty(exports, "agentsList", { enumerable: true, get: function () { return agents_1.agentsList; } });
+Object.defineProperty(exports, "agentDoc", { enumerable: true, get: function () { return agents_1.agentDoc; } });
+Object.defineProperty(exports, "agentDispatcher", { enumerable: true, get: function () { return agents_1.agentDispatcher; } });
+Object.defineProperty(exports, "agentRunner", { enumerable: true, get: function () { return agents_1.agentRunner; } });
+Object.defineProperty(exports, "nonStreamAgentDispatcher", { enumerable: true, get: function () { return agents_1.nonStreamAgentDispatcher; } });
+Object.defineProperty(exports, "streamAgentDispatcher", { enumerable: true, get: function () { return agents_1.streamAgentDispatcher; } });
+var graph_1 = require("./graph");
+Object.defineProperty(exports, "graphRunner", { enumerable: true, get: function () { return graph_1.graphRunner; } });
+Object.defineProperty(exports, "streamGraphRunner", { enumerable: true, get: function () { return graph_1.streamGraphRunner; } });
+Object.defineProperty(exports, "nonStreamGraphRunner", { enumerable: true, get: function () { return graph_1.nonStreamGraphRunner; } });

package/lib/type.d.ts

@@ -1,4 +1,4 @@
-import type { AgentFunctionInfoSample } from "graphai";
+import type { AgentFunctionInfoSample, AgentFunctionContext } from "graphai";
 export type ExpressAgentInfo = {
     agentId: string;
     name: string;
@@ -13,3 +13,4 @@ export type ExpressAgentInfo = {
     output: any;
     stream: boolean;
 };
+export type StreamChunkCallback = (context: AgentFunctionContext, token: string) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@receptron/graphai_express",
-  "version": "0.0.26",
+  "version": "0.0.28",
   "description": "GraphAI express web server middleware.",
   "main": "lib/index.js",
   "files": [
@@ -11,6 +11,7 @@
     "eslint": "eslint --fix",
     "server": "ts-node -r tsconfig-paths/register test/express.ts",
     "test_stream": "ts-node -r tsconfig-paths/register test/stream_client.ts",
+    "test_stream2": "ts-node -r tsconfig-paths/register test/stream_graph.ts",
     "test": "ts-node -r tsconfig-paths/register test/client.ts",
     "format": "prettier --write '{src,test}/**/*.{yaml,ts,json}'",
     "ci": "yarn run format && yarn run eslint && yarn run build"
@@ -29,8 +30,12 @@
     "@graphai/agents": "^0.0.21",
     "@types/express": "^4.17.21",
     "@types/node": "^20.14.12",
+    "@types/sinon": "^17.0.3",
+    "@types/sinon-express-mock": "^1.3.12",
     "eslint": "^9.7.0",
     "prettier": "^3.3.3",
+    "sinon": "^18.0.0",
+    "sinon-express-mock": "^2.2.1",
     "ts-node": "^10.9.2",
     "tsc-alias": "^1.8.8",
     "tsconfig-paths": "^4.2.0",