@receptron/graphai_express 1.0.0 → 1.0.2

package/lib/agents.js

@@ -168,7 +168,8 @@ const agentDispatcherInternal = (agentDictionary, agentFilters = [], isDispatch
             filterParams,
         };
         if (graphaiExpressVerbose) {
-            console.log("agentDispatcherInternal(context): ", context);
+            const { agents: __nonLog, ...logContext } = context;
+            console.log("agentDispatcherInternal(context): ", logContext);
         }
         const agentFilterRunner = (0, agent_filters_1.agentFilterRunnerBuilder)(agentFilters);
         const result = await agentFilterRunner(context, agent.agent);

package/lib/completions.d.ts

@@ -0,0 +1,4 @@
+import express from "express";
+import type { AgentFunctionInfoDictionary, AgentFilterInfo, TransactionLog } from "graphai";
+import type { Model2GraphData } from "./type";
+export declare const completionRunner: (agentDictionary: AgentFunctionInfoDictionary, model2GraphData: Model2GraphData, agentFilters?: AgentFilterInfo[], onLogCallback?: (__log: TransactionLog, __isUpdate: boolean) => void) => (req: express.Request, res: express.Response, next: express.NextFunction) => Promise<express.Response<any, Record<string, any>> | undefined>;

package/lib/completions.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.completionRunner = void 0;
+const graphai_1 = require("graphai");
+const agent_filters_1 = require("@graphai/agent_filters");
+const crypto_1 = require("crypto");
+// TODO choise graph(done)
+// stream flag(done);
+// non stream api(done);
+const streamCompletionChunkCallback = (data, status, token) => {
+    if (status === "done") {
+        return "data: [DONE]\n\n";
+    }
+    const payload = (() => {
+        if (status === "start") {
+            return {
+                object: "chat.completion.chunk",
+                choices: [{ index: 0, delta: { role: "assistant", content: "" }, logprobs: null, finish_reason: null }],
+            };
+        }
+        if (status === "end") {
+            return {
+                object: "chat.completion.chunk",
+                choices: [{ index: 0, delta: {}, logprobs: null, finish_reason: "stop" }],
+            };
+        }
+        return {
+            object: "chat.completion.chunk",
+            choices: [{ index: 0, delta: { content: token }, logprobs: null, finish_reason: null }],
+        };
+    })();
+    return "data: " + JSON.stringify({ ...data, ...payload }) + "\n\n";
+};
+const completionRunner = (agentDictionary, model2GraphData, agentFilters = [], onLogCallback = (__log, __isUpdate) => { }) => {
+    const streamRunner = streamGraphRunner(agentDictionary, model2GraphData, agentFilters, onLogCallback);
+    const nonStreamRunner = nonStreamGraphRunner(agentDictionary, model2GraphData, agentFilters, onLogCallback);
+    return async (req, res, next) => {
+        const { stream, model, messages } = req.body;
+        // validation
+        if (!model || typeof model !== "string") {
+            return res.status(400).json({
+                error: {
+                    message: "`model` is required and must be a string",
+                    type: "invalid_request_error",
+                    param: "model",
+                    code: "invalid_model",
+                },
+            });
+        }
+        if (!messages || !Array.isArray(messages) || messages.length === 0) {
+            return res.status(400).json({
+                error: {
+                    message: "`messages` must be an array of objects with `role` and `content` as strings",
+                    type: "invalid_request_error",
+                    param: "messages",
+                    code: "invalid_messages",
+                },
+            });
+        }
+        // const isStreaming = (req.headers["content-type"] || "").startsWith("text/event-stream")
+        if (stream) {
+            return await streamRunner(req, res, next);
+        }
+        return await nonStreamRunner(req, res, next);
+    };
+};
+exports.completionRunner = completionRunner;
+const streamGraphRunner = (agentDictionary, model2GraphData, agentFilters = [], onLogCallback = (__log, __isUpdate) => { }) => {
+    return async (req, res, next) => {
+        const { model } = req.body;
+        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 baseData = {
+                id: (0, crypto_1.randomUUID)(),
+                created: Math.floor(Date.now() / 1000),
+                model,
+            };
+            const streamCallback = (context, token) => {
+                if (token) {
+                    res.write(streamCompletionChunkCallback(baseData, "payload", token));
+                }
+            };
+            const streamAgentFilter = {
+                name: "streamAgentFilter",
+                agent: (0, agent_filters_1.streamAgentFilterGenerator)(streamCallback),
+            };
+            const filterList = [...agentFilters, streamAgentFilter];
+            res.write(streamCompletionChunkCallback(baseData, "start"));
+            try {
+                const dispatcher = streamGraphRunnerInternal(agentDictionary, model2GraphData, filterList, onLogCallback);
+                await dispatcher(req);
+                res.write(streamCompletionChunkCallback(baseData, "end"));
+                res.write(streamCompletionChunkCallback(baseData, "done"));
+            }
+            catch (__err) {
+                res.write(`data: ${JSON.stringify({ error: "GraphAI Something went wrong" })}\n\n`);
+            }
+            return res.end();
+        }
+        catch (e) {
+            next(e);
+        }
+    };
+};
+const nonStreamGraphRunner = (agentDictionary, model2GraphData, agentFilters = [], onLogCallback = (__log, __isUpdate) => { }) => {
+    return async (req, res, next) => {
+        try {
+            const dispatcher = streamGraphRunnerInternal(agentDictionary, model2GraphData, agentFilters, onLogCallback);
+            const result = await dispatcher(req);
+            return res.json(result);
+        }
+        catch (e) {
+            next(e);
+        }
+    };
+};
+// internal function
+const streamGraphRunnerInternal = (agentDictionary, model2GraphData, agentFilters = [], onLogCallback = (__log, __isUpdate) => { }) => {
+    return async (req) => {
+        const { messages, model } = req.body;
+        const { config } = req;
+        const graphData = model2GraphData(model);
+        const graphai = new graphai_1.GraphAI(graphData, agentDictionary, { agentFilters, config: config ?? {} });
+        // injectValue
+        graphai.injectValue("messages", messages);
+        graphai.onLogCallback = onLogCallback;
+        const result = await graphai.run();
+        return result;
+    };
+};

package/lib/index.d.ts

@@ -1,3 +1,4 @@
 export { agentsList, agentDoc, agentDispatcher, agentRunner, nonStreamAgentDispatcher, streamAgentDispatcher, updateAgentVerbose } from "./agents";
 export { graphRunner, streamGraphRunner, nonStreamGraphRunner } from "./graph";
-export { ExpressAgentInfo, StreamChunkCallback, ContentCallback } from "./type";
+export { completionRunner } from "./completions";
+export { ExpressAgentInfo, StreamChunkCallback, ContentCallback, Model2GraphData } from "./type";

package/lib/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.nonStreamGraphRunner = exports.streamGraphRunner = exports.graphRunner = exports.updateAgentVerbose = exports.streamAgentDispatcher = exports.nonStreamAgentDispatcher = exports.agentRunner = exports.agentDispatcher = exports.agentDoc = exports.agentsList = void 0;
+exports.completionRunner = exports.nonStreamGraphRunner = exports.streamGraphRunner = exports.graphRunner = exports.updateAgentVerbose = 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; } });
@@ -13,3 +13,5 @@ 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; } });
+var completions_1 = require("./completions");
+Object.defineProperty(exports, "completionRunner", { enumerable: true, get: function () { return completions_1.completionRunner; } });

package/lib/type.d.ts

@@ -1,4 +1,4 @@
-import type { AgentFunctionInfoSample, AgentFunctionContext } from "graphai";
+import type { AgentFunctionInfoSample, AgentFunctionContext, GraphData } from "graphai";
 export type ExpressAgentInfo = {
     agentId: string;
     name: string;
@@ -13,6 +13,14 @@ export type ExpressAgentInfo = {
     output: any;
     stream: boolean;
 };
+type BaseData = {
+    id: string;
+    created: number;
+    model: string;
+};
 export type StreamChunkCallback = <T = string | Record<string, string>>(context: AgentFunctionContext, token: T) => void;
+export type StreamCompletionChunkCallback = <T = string | Record<string, string>>(data: BaseData, status: string, token?: T) => void;
+export type Model2GraphData = (model: string) => GraphData;
 export type ContentCallback = <T = string | Record<string, string>>(token: T) => void;
 export declare const DefaultEndOfStreamDelimiter = "___END___";
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@receptron/graphai_express",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "GraphAI express web server middleware.",
   "main": "lib/index.js",
   "files": [