graphai 0.0.5 → 0.0.7

package/.eslintrc.js

@@ -1,49 +1,30 @@
 module.exports = {
-    "env": {
-        "es2021": true,
-        "node": true
+  env: {
+    es2021: true,
+    node: true,
+  },
+  extends: ["eslint:recommended", "plugin:@typescript-eslint/recommended"],
+  overrides: [
+    {
+      env: {
+        node: true,
+      },
+      files: [".eslintrc.{js,cjs}"],
+      parserOptions: {
+        sourceType: "script",
+      },
     },
-    "extends": [
-        "eslint:recommended",
-        "plugin:@typescript-eslint/recommended"
-    ],
-    "overrides": [
-        {
-            "env": {
-                "node": true
-            },
-            "files": [
-                ".eslintrc.{js,cjs}"
-            ],
-            "parserOptions": {
-                "sourceType": "script"
-            }
-        }
-    ],
-    "parser": "@typescript-eslint/parser",
-    "parserOptions": {
-        "ecmaVersion": "latest",
-        "sourceType": "module"
-    },
-    "plugins": [
-        "@typescript-eslint"
-    ],
-    "rules": {
-        "indent": [
-            "error",
-            2
-        ],
-        "linebreak-style": [
-            "error",
-            "unix"
-        ],
-        "quotes": [
-            "error",
-            "double"
-        ],
-        "semi": [
-            "error",
-            "always"
-        ]
-    }
+  ],
+  parser: "@typescript-eslint/parser",
+  parserOptions: {
+    ecmaVersion: "latest",
+    sourceType: "module",
+  },
+  plugins: ["@typescript-eslint"],
+  rules: {
+    indent: ["error", 2],
+    "linebreak-style": ["error", "unix"],
+    quotes: ["error", "double"],
+    semi: ["error", "always"],
+  },
 };

package/.github/workflows/node.js.yml

@@ -24,4 +24,5 @@ jobs:
         node-version: ${{ matrix.node-version }}
         cache: 'npm'
     - run: yarn install
+    - run: cd tests/http-server/docs/ && npx http-server &
     - run: yarn test

package/README.md

@@ -1,8 +1,10 @@
 # GraphAI
 
+## Overview
+
 GraphAI is an asynchronous data flow execution engine, which makes it easy to create AI applications that need to make asynchronous AI API calls multiple times with some dependencies among them, such as giving the answer from one LLM call to another LLM call as a prompt.
 
-You just need to describe dependencies among those API calls in a single graph definition file (in JSON or YAML), create a GraphAI object with it, and run it.
+You just need to describe dependencies among those API calls in a single data flow graph (typically in YAML), create a GraphAI object with it, and run it.
 
 Here is an example:
 
@@ -10,34 +12,99 @@ Here is an example:
 nodes:
   taskA:
     params:
-      // app-specific parameters for taskA
+      // agent-specific parameters for taskA
   taskB:
     params:
-      // app-specific parameters for taskB
+      // agent-specific parameters for taskB
   taskC:
     params:
-      // app-specific parameters for taskC
+      // agent-specific parameters for taskC
     inputs: [taskA, taskB]
 ```
 
 ``` TypeScript
-const nodeExecute = async (context: NodeExecuteContext) => {
+const sampleAgentFunction = async (context: AgentFunctionContext) => {
   const { 
     nodeId, // taskA, taskB or taskC 
-    params, // app-specific/task-specific parameters specified in the graph definition file
+    params, // agent-specific parameters specified in the graph definition file
     payload // for taskC, { taskA: resultA, taskB: resultB }
   } = context;
-  // App-specific code (such as calling OpenAI's chat.completions API)
+  // Agent-specific code (such as calling OpenAI's chat.completions API)
   ...
   return result;
 }
 
   ...
   const file = fs.readFileSync(pathToYamlFile, "utf8");
-  const graphdata = YAML.parse(file);
-  const graph = new GraphAI(graph_data, nodeExecute);
+  const graphData = YAML.parse(file);
+  const graph = new GraphAI(graphData, sampleAgentFunction);
   const results = await graph.run();
   return results["taskC"];
 ```
 
+## Data Flow Graph
+
+A Data Flow Graph (DFG) is a JavaScript object, which defines the flow of data. It is typically described in YAML file and loaded at runtime.
+
+A DFG consists of a collection of 'nodes', which contains a series of nested keys representing individual nodes in the data flow. Each node is identified by a unique key (e.g., node1, node2) and can contain several predefined keys (params, inputs, retry, timeout, source, dispatch, agentId) that dictate the node's behavior and its relationship with other nodes.
+
+### DFG Structure
+
+- 'nodes': A list of node. Required.
+- 'concurrency': An optional property, which specifies the maximum number of concurrent operations (agent functions to be executed at the same time). The default is 8.
+
+## Agent
+
+An agent is an abstract object, which takes some inputs and generates an output asynchronously. It could be an LLM (such as GPT-4), an image/video/music generator, a database, or a REST API over HTTP. Each node (except 'source node') is associated with an agent function, which takes data flow into the node as inputs, and generates an output.
+
+## Agent function
+
+An agent function is a TypeScript function, which implements an agent. A DFG is associated one or more agent functions. If the DFG is associated with multiple agent functions, each node needs to be associated only one of them (either explicitly with 'agentId' or implicitly to the default Agent function).
+
+An agent function receives two set of parameters via AgentFunctionContext, agent specific parameters specified in the DFG and input data came from other nodes (payload).
+
+A regular agent function returns the data (type: ```Record<string, any>```), but a dispatcher agent function returns the date with outputID(s) (type: ```Record<string: Record<string, any>>```). 
+
+## Node Structure
+
+- 'inputs': An optional list of node identifiers that the current node depends on. This establishes a flow where the current node can only be executed after the completion of the nodes listed under 'inputs'. If this list is empty and the 'source' property is not set, the associated Agent Function will be immediatley executed. 
+- 'source': An optional flag, which specifies if the node is a 'source node' or not. A souce node is a special node, which receives data from either an external code (via GraphAI's injectResult method) or from a 'dispatcher node'.
+- 'dispatch': An optinal property (type: ```Record<string, string>```) which indicates that the current node is a 'dispatcher node'. A dispatcher node is associated is a dispaher-style agent function, which has multiple possible 'outputs'.
+- 'retry': An optional number, which specifies the maximum number of retries to be made. If the last attempt fails, that return value will be recorded.
+- 'timeout': An optional number, which specifies the maximum waittime in msec. If the associated agent function does not return the value in time, the "Timeout" error will be recorded and the returned value will be discarded. 
+- 'params': An optional parameters to the associated agent function, which are agent specific.
+- 'payloadMapping': An optional property (type: ```Record<string, string>```), which maps input nodeIds to agent specific inputIDs.
+
+## GraphAI class
+
+### ```constructor(data: GraphData, callbackDictonary: AgentFunctionDictonary | AgentFunction<any, any, any>)```
+Initializes a new instance of the GraphAI class with the specified graph data and a dictionary of callback functions.
+
+- ```data: GraphData```: The graph data including nodes and optional concurrency limit.
+- ```callbackDictonary: AgentFunctionDictonary | AgentFunction<any, any, any>```: A dictionary mapping agent IDs to their respective callback functions, or a single default callback function to be used for all nodes.
+
+### ```async run(): Promise<ResultDataDictonary<ResultData>>```
+Executes the graph asynchronously, starting with nodes that have no dependencies or whose dependencies have been met. The method continues to execute nodes as their dependencies are satisfied until all nodes have been executed or an error occurs.
+
+Returns: A promise that resolves with the results of all executed nodes or rejects with the first encountered error.
+
+### ```results(): ResultDataDictonary<ResultData>```
+Compiles and returns the results of all executed nodes in the graph.
+
+Returns: A dictionary mapping node IDs to their results. Only includes nodes that have completed execution and produced a result.
+
+### ```errors(): Record<string, Error>```
+Compiles and returns the errors from all nodes that encountered an error during execution.
+
+Returns: A dictionary mapping node IDs to the errors they encountered. Only includes nodes that have executed and encountered an error. It does not include any errors which have been retried.
+
+### ```transactionLogs(): Array<TransactionLog>```
+Retrieves all transaction logs recorded during the execution of the graph.
+
+Returns: An array of transaction logs detailing the execution states and outcomes of the nodes within the graph.
+
+### ```injectResult(nodeId: string, result: ResultData): void```
+Injects a result into a specified node. This is used to manually set the result of a source node, allowing dependent nodes to proceed with execution.
 
+- ```nodeId: string```: The ID of the source node into which the result is to be injected.
+- ```result: ResultData```: The result to be injected into the specified node.

package/lib/graphai.d.ts

@@ -1,54 +1,66 @@
 export declare enum NodeState {
-    Waiting = 0,
-    Executing = 1,
-    Failed = 2,
-    TimedOut = 3,
-    Completed = 4
+    Waiting = "waiting",
+    Executing = "executing",
+    Failed = "failed",
+    TimedOut = "timed-out",
+    Completed = "completed",
+    Injected = "injected",
+    Dispatched = "dispatched"
 }
 type ResultData<ResultType = Record<string, any>> = ResultType | undefined;
 type ResultDataDictonary<ResultType = Record<string, any>> = Record<string, ResultData<ResultType>>;
 export type NodeDataParams<ParamsType = Record<string, any>> = ParamsType;
 type NodeData = {
-    inputs: undefined | Array<string>;
+    inputs?: Array<string>;
     params: NodeDataParams;
-    retry: undefined | number;
-    timeout: undefined | number;
-    functionName: undefined | string;
+    payloadMapping?: Record<string, string>;
+    retry?: number;
+    timeout?: number;
+    agentId?: string;
+    source?: boolean;
+    dispatch?: Record<string, string>;
 };
-type GraphData = {
+export type GraphData = {
     nodes: Record<string, NodeData>;
-    concurrency: number;
-};
-type NodeExecuteContext<ResultType, ParamsType> = {
-    nodeId: string;
-    retry: number;
-    params: NodeDataParams<ParamsType>;
-    payload: ResultDataDictonary<ResultType>;
+    concurrency?: number;
 };
 export type TransactionLog = {
     nodeId: string;
     state: NodeState;
-    startTime: undefined | number;
-    endTime: undefined | number;
+    startTime: number;
+    endTime?: number;
     retryCount: number;
-    error: undefined | Error;
+    agentId?: string;
+    params?: NodeDataParams;
+    payload?: ResultDataDictonary<ResultData>;
+    errorMessage?: string;
     result?: ResultData;
 };
-export type NodeExecute<ResultType = Record<string, any>, ParamsType = Record<string, any>> = (context: NodeExecuteContext<ResultType, ParamsType>) => Promise<ResultData<ResultType>>;
+export type AgentFunctionContext<ParamsType, ResultType, PreviousResultType> = {
+    nodeId: string;
+    retry: number;
+    params: NodeDataParams<ParamsType>;
+    payload: ResultDataDictonary<PreviousResultType>;
+};
+export type AgentFunction<ParamsType = Record<string, any>, ResultType = Record<string, any>, PreviousResultType = Record<string, any>> = (context: AgentFunctionContext<ParamsType, ResultType, PreviousResultType>) => Promise<ResultData<ResultType>>;
+export type AgentFunctionDictonary = Record<string, AgentFunction<any, any, any>>;
 declare class Node {
     nodeId: string;
     params: NodeDataParams;
     inputs: Array<string>;
+    payloadMapping: Record<string, string>;
     pendings: Set<string>;
     waitlist: Set<string>;
     state: NodeState;
-    functionName: string;
+    agentId: string;
     result: ResultData;
     retryLimit: number;
     retryCount: number;
     transactionId: undefined | number;
-    timeout: number;
-    error: undefined | Error;
+    timeout?: number;
+    error?: Error;
+    source: boolean;
+    dispatch?: Record<string, string>;
     private graph;
     constructor(nodeId: string, data: NodeData, graph: GraphAI);
     asString(): string;
@@ -56,20 +68,22 @@ declare class Node {
     removePending(nodeId: string): void;
     payload(): ResultDataDictonary<Record<string, any>>;
     pushQueueIfReady(): void;
+    injectResult(result: ResultData): void;
+    private setResult;
     execute(): Promise<void>;
 }
 type GraphNodes = Record<string, Node>;
-type NodeExecuteDictonary = Record<string, NodeExecute>;
 export declare class GraphAI {
     nodes: GraphNodes;
-    callbackDictonary: NodeExecuteDictonary;
+    callbackDictonary: AgentFunctionDictonary;
+    isRunning: boolean;
     private runningNodes;
     private nodeQueue;
     private onComplete;
     private concurrency;
     private logs;
-    constructor(data: GraphData, callbackDictonary: NodeExecuteDictonary | NodeExecute);
-    getCallback(functionName: string): NodeExecute<Record<string, any>, Record<string, any>>;
+    constructor(data: GraphData, callbackDictonary: AgentFunctionDictonary | AgentFunction<any, any, any>);
+    getCallback(agentId: string): AgentFunction<any, any, any>;
     asString(): string;
     results(): ResultDataDictonary<Record<string, any>>;
     errors(): Record<string, Error>;
@@ -79,5 +93,6 @@ export declare class GraphAI {
     removeRunning(node: Node): void;
     appendLog(log: TransactionLog): void;
     transactionLogs(): TransactionLog[];
+    injectResult(nodeId: string, result: ResultData): void;
 }
 export {};

package/lib/graphai.js

@@ -3,25 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GraphAI = exports.NodeState = void 0;
 var NodeState;
 (function (NodeState) {
-    NodeState[NodeState["Waiting"] = 0] = "Waiting";
-    NodeState[NodeState["Executing"] = 1] = "Executing";
-    NodeState[NodeState["Failed"] = 2] = "Failed";
-    NodeState[NodeState["TimedOut"] = 3] = "TimedOut";
-    NodeState[NodeState["Completed"] = 4] = "Completed";
+    NodeState["Waiting"] = "waiting";
+    NodeState["Executing"] = "executing";
+    NodeState["Failed"] = "failed";
+    NodeState["TimedOut"] = "timed-out";
+    NodeState["Completed"] = "completed";
+    NodeState["Injected"] = "injected";
+    NodeState["Dispatched"] = "dispatched";
 })(NodeState || (exports.NodeState = NodeState = {}));
 class Node {
     constructor(nodeId, data, graph) {
+        this.waitlist = new Set(); // List of nodes which need data from this node.
+        this.state = NodeState.Waiting;
+        this.result = undefined;
+        this.retryCount = 0;
         this.nodeId = nodeId;
         this.inputs = data.inputs ?? [];
+        this.payloadMapping = data.payloadMapping ?? {};
         this.pendings = new Set(this.inputs);
         this.params = data.params;
-        this.waitlist = new Set();
-        this.state = NodeState.Waiting;
-        this.functionName = data.functionName ?? "default";
-        this.result = undefined;
+        this.agentId = data.agentId ?? "default";
         this.retryLimit = data.retry ?? 0;
-        this.retryCount = 0;
-        this.timeout = data.timeout ?? 0;
+        this.timeout = data.timeout;
+        this.source = data.source === true;
+        this.dispatch = data.dispatch;
         this.graph = graph;
     }
     asString() {
@@ -36,43 +41,77 @@ class Node {
             this.state = state;
             this.result = undefined;
             this.error = error;
-            this.transactionId = 0; // This is necessary for timeout case
+            this.transactionId = undefined; // This is necessary for timeout case
             this.graph.removeRunning(this);
         }
     }
     removePending(nodeId) {
         this.pendings.delete(nodeId);
-        this.pushQueueIfReady();
+        if (this.graph.isRunning) {
+            this.pushQueueIfReady();
+        }
     }
     payload() {
         return this.inputs.reduce((results, nodeId) => {
-            results[nodeId] = this.graph.nodes[nodeId].result;
+            if (this.payloadMapping && this.payloadMapping[nodeId]) {
+                results[this.payloadMapping[nodeId]] = this.graph.nodes[nodeId].result;
+            }
+            else {
+                results[nodeId] = this.graph.nodes[nodeId].result;
+            }
             return results;
         }, {});
     }
     pushQueueIfReady() {
-        if (this.pendings.size === 0) {
+        if (this.pendings.size === 0 && !this.source) {
             this.graph.pushQueue(this);
         }
     }
+    injectResult(result) {
+        if (this.source) {
+            const log = {
+                nodeId: this.nodeId,
+                retryCount: this.retryCount,
+                state: NodeState.Injected,
+                startTime: Date.now(),
+            };
+            log.endTime = log.startTime;
+            this.graph.appendLog(log);
+            this.setResult(result, NodeState.Injected);
+        }
+        else {
+            console.error("- injectResult called on non-source node.", this.nodeId);
+        }
+    }
+    setResult(result, state) {
+        this.state = state;
+        this.result = result;
+        this.waitlist.forEach((nodeId) => {
+            const node = this.graph.nodes[nodeId];
+            // Todo: Avoid running before Run()
+            node.removePending(this.nodeId);
+        });
+    }
     async execute() {
+        const payload = this.payload();
         const log = {
             nodeId: this.nodeId,
             retryCount: this.retryCount,
             state: NodeState.Executing,
             startTime: Date.now(),
-            endTime: undefined,
-            error: undefined,
+            agentId: this.agentId,
+            params: this.params,
+            payload,
         };
         this.graph.appendLog(log);
         this.state = NodeState.Executing;
         const transactionId = log.startTime;
         this.transactionId = transactionId;
-        if (this.timeout > 0) {
+        if (this.timeout && this.timeout > 0) {
             setTimeout(() => {
                 if (this.state === NodeState.Executing && this.transactionId === transactionId) {
                     console.log(`-- ${this.nodeId}: timeout ${this.timeout}`);
-                    log.error = Error("Timeout");
+                    log.errorMessage = "Timeout";
                     log.state = NodeState.TimedOut;
                     log.endTime = Date.now();
                     this.retry(NodeState.TimedOut, Error("Timeout"));
@@ -80,26 +119,32 @@ class Node {
             }, this.timeout);
         }
         try {
-            const callback = this.graph.getCallback(this.functionName);
+            const callback = this.graph.getCallback(this.agentId);
             const result = await callback({
                 nodeId: this.nodeId,
                 retry: this.retryCount,
                 params: this.params,
-                payload: this.payload(),
+                payload,
             });
             if (this.transactionId !== transactionId) {
                 console.log(`-- ${this.nodeId}: transactionId mismatch`);
                 return;
             }
-            log.state = NodeState.Completed;
             log.endTime = Date.now();
             log.result = result;
-            this.state = NodeState.Completed;
-            this.result = result;
-            this.waitlist.forEach((nodeId) => {
-                const node = this.graph.nodes[nodeId];
-                node.removePending(this.nodeId);
-            });
+            const dispatch = this.dispatch;
+            if (dispatch !== undefined) {
+                Object.keys(result).forEach((outputId) => {
+                    const nodeId = dispatch[outputId];
+                    this.graph.injectResult(nodeId, result[outputId]);
+                });
+                log.state = NodeState.Dispatched;
+                this.state = NodeState.Dispatched;
+                this.graph.removeRunning(this);
+                return;
+            }
+            log.state = NodeState.Completed;
+            this.setResult(result, NodeState.Completed);
             this.graph.removeRunning(this);
         }
         catch (error) {
@@ -110,12 +155,12 @@ class Node {
             log.state = NodeState.Failed;
             log.endTime = Date.now();
             if (error instanceof Error) {
-                log.error = error;
+                log.errorMessage = error.message;
                 this.retry(NodeState.Failed, error);
             }
             else {
                 console.error(`-- ${this.nodeId}: Unexpecrted error was caught`);
-                log.error = Error("Unknown");
+                log.errorMessage = "Unknown";
                 this.retry(NodeState.Failed, Error("Unknown"));
             }
         }
@@ -124,15 +169,18 @@ class Node {
 const defaultConcurrency = 8;
 class GraphAI {
     constructor(data, callbackDictonary) {
+        this.isRunning = false;
+        this.runningNodes = new Set();
+        this.nodeQueue = [];
         this.logs = [];
         this.callbackDictonary = typeof callbackDictonary === "function" ? { default: callbackDictonary } : callbackDictonary;
         if (this.callbackDictonary["default"] === undefined) {
             throw new Error("No default function");
         }
         this.concurrency = data.concurrency ?? defaultConcurrency;
-        this.runningNodes = new Set();
-        this.nodeQueue = [];
-        this.onComplete = () => { };
+        this.onComplete = () => {
+            console.error("-- SOMETHING IS WRONG: onComplete is called without run()");
+        };
         this.nodes = Object.keys(data.nodes).reduce((nodes, nodeId) => {
             nodes[nodeId] = new Node(nodeId, data.nodes[nodeId], this);
             return nodes;
@@ -146,9 +194,9 @@ class GraphAI {
             });
         });
     }
-    getCallback(functionName) {
-        if (functionName && this.callbackDictonary[functionName]) {
-            return this.callbackDictonary[functionName];
+    getCallback(agentId) {
+        if (agentId && this.callbackDictonary[agentId]) {
+            return this.callbackDictonary[agentId];
         }
         return this.callbackDictonary["default"];
     }
@@ -178,6 +226,10 @@ class GraphAI {
         }, {});
     }
     async run() {
+        if (this.isRunning) {
+            console.error("-- Already Running");
+        }
+        this.isRunning = true;
         // Nodes without pending data should run immediately.
         Object.keys(this.nodes).forEach((nodeId) => {
             const node = this.nodes[nodeId];
@@ -185,6 +237,7 @@ class GraphAI {
         });
         return new Promise((resolve, reject) => {
             this.onComplete = () => {
+                this.isRunning = false;
                 const errors = this.errors();
                 const nodeIds = Object.keys(errors);
                 if (nodeIds.length > 0) {
@@ -226,5 +279,14 @@ class GraphAI {
     transactionLogs() {
         return this.logs;
     }
+    injectResult(nodeId, result) {
+        const node = this.nodes[nodeId];
+        if (node) {
+            node.injectResult(result);
+        }
+        else {
+            console.error("-- Invalid nodeId", nodeId);
+        }
+    }
 }
 exports.GraphAI = GraphAI;

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "graphai",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Asynchronous data flow execution engine to make it simple to build LLM apps.",
   "main": "lib/index.js",
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && tsc-alias",
     "eslint": "eslint --fix --ext src/**/*.{ts} tests/**/*.ts",
-    "format": "prettier --write '{src,tests}/**/*.ts'",
-    "test": "node --test --require ts-node/register ./tests/test_*.ts",
-    "gpt": "npx ts-node ./samples/sample_gpt.ts"
+    "format": "prettier --write '{src,tests,samples}/**/*.ts' .eslintrc.js",
+    "test": "node --test  -r tsconfig-paths/register --require ts-node/register ./tests/**/test_*.ts",
+    "gpt": "npx ts-node  -r tsconfig-paths/register ./samples/sample_gpt.ts"
   },
   "repository": {
     "type": "git",
@@ -21,15 +21,20 @@
   },
   "homepage": "https://github.com/snakajima/graphai#readme",
   "devDependencies": {
+    "@types/express": "^4.17.21",
     "@types/node": "^20.8.7",
     "@typescript-eslint/eslint-plugin": "^6.8.0",
     "@typescript-eslint/parser": "^6.8.0",
+    "arxiv-api-ts": "^1.0.3",
     "eslint": "^7.32.0 || ^8.2.0",
     "eslint-plugin-import": "^2.25.2",
+    "express": "^4.19.2",
     "openai": "^4.12.4",
     "prettier": "^3.0.3",
     "slashgpt": "^0.0.8",
     "ts-node": "^10.9.1",
+    "tsc-alias": "^1.8.8",
+    "tsconfig-paths": "^4.2.0",
     "typescript": "^5.2.2"
   },
   "dependencies": {

package/samples/agents/arxiv_agent.ts

@@ -0,0 +1,46 @@
+import search from "arXiv-api-ts";
+
+import { AgentFunction } from "@/graphai";
+
+type arxivData = { id: string; title: string; summary: string };
+
+const search_arxiv_papers = async (keywords: string[], limit = 10) => {
+  const includes = keywords.map((k) => {
+    return { name: k };
+  });
+  const papers = await search({
+    searchQueryParams: [
+      {
+        include: includes,
+      },
+    ],
+    sortBy: "lastUpdatedDate",
+    sortOrder: "descending",
+    start: 0,
+    maxResults: limit,
+  });
+  return papers.entries || [];
+};
+
+export const arxivAgent: AgentFunction<{ keywords: string[]; limit: number }, arxivData[]> = async (context) => {
+  const { keywords, limit } = context.params;
+  const arxivResult = await search_arxiv_papers(keywords, limit);
+  // console.log("executing", arxivResult, context.params.keywords);
+
+  const result = arxivResult.map((r: any) => {
+    const { id, title, summary } = r;
+    return { id, title, summary };
+  });
+  return result;
+};
+
+export const arxiv2TextAgent: AgentFunction<{}, string, string[]> = async (context) => {
+  const result = (context?.payload?.inputData || [])
+    .map((r: any) => {
+      const { id, title, summary } = r;
+      return ["id:", id, "title:", title, "summary:", summary].join("\n");
+    })
+    .join("\n\n\n");
+
+  return result;
+};