graphai 0.0.10 → 0.0.12

package/lib/graphai.js

@@ -11,22 +11,38 @@ var NodeState;
     NodeState["Injected"] = "injected";
     NodeState["Dispatched"] = "dispatched";
 })(NodeState || (exports.NodeState = NodeState = {}));
+const parseNodeName = (name) => {
+    const parts = name.split(".");
+    if (parts.length == 1) {
+        return { sourceNodeId: parts[0] };
+    }
+    else {
+        return { sourceNodeId: parts[0], propId: parts[1] };
+    }
+};
 class Node {
     constructor(nodeId, forkIndex, data, graph) {
+        this.inputProps = {}; // optional properties for input
         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.forkIndex = forkIndex;
-        this.inputs = data.inputs ?? [];
+        this.inputs = (data.inputs ?? []).map((input) => {
+            const { sourceNodeId, propId } = parseNodeName(input);
+            if (propId) {
+                this.inputProps[sourceNodeId] = propId;
+            }
+            return sourceNodeId;
+        });
         this.pendings = new Set(this.inputs);
         this.params = data.params ?? {};
-        this.agentId = data.agentId;
+        this.agentId = data.agentId ?? graph.agentId;
         this.fork = data.fork;
         this.retryLimit = data.retry ?? 0;
         this.timeout = data.timeout;
-        this.source = data.source === true;
+        this.source = this.agentId === undefined;
         this.outputs = data.outputs;
         this.graph = graph;
     }
@@ -54,10 +70,18 @@ class Node {
     }
     pushQueueIfReady() {
         if (this.pendings.size === 0 && !this.source) {
+            // If input property is specified, we need to ensure that the property value exists.
+            Object.keys(this.inputProps).forEach((nodeId) => {
+                const [result] = this.graph.resultsOf([nodeId]);
+                const propId = this.inputProps[nodeId];
+                if (!result || !(propId in result)) {
+                    return;
+                }
+            });
             this.graph.pushQueue(this);
         }
     }
-    injectResult(result) {
+    injectValue(value) {
         if (this.source) {
             const log = {
                 nodeId: this.nodeId,
@@ -65,13 +89,13 @@ class Node {
                 state: NodeState.Injected,
                 startTime: Date.now(),
                 endTime: Date.now(),
-                result,
+                result: value,
             };
             this.graph.appendLog(log);
-            this.setResult(result, NodeState.Injected);
+            this.setResult(value, NodeState.Injected);
         }
         else {
-            console.error("- injectResult called on non-source node.", this.nodeId);
+            console.error("- injectValue called on non-source node.", this.nodeId);
         }
     }
     setResult(result, state) {
@@ -85,15 +109,21 @@ class Node {
     }
     async execute() {
         const results = this.graph.resultsOf(this.inputs);
+        this.inputs.forEach((nodeId, index) => {
+            const propId = this.inputProps[nodeId];
+            if (propId) {
+                results[index] = results[index][propId];
+            }
+        });
         const transactionId = Date.now();
         const log = {
             nodeId: this.nodeId,
-            retryCount: this.retryCount,
+            retryCount: this.retryCount > 0 ? this.retryCount : undefined,
             state: NodeState.Executing,
             startTime: transactionId,
             agentId: this.agentId,
             params: this.params,
-            inputs: results,
+            inputs: results.length > 0 ? results : undefined,
         };
         this.graph.appendLog(log);
         this.state = NodeState.Executing;
@@ -111,12 +141,16 @@ class Node {
         }
         try {
             const callback = this.graph.getCallback(this.agentId);
+            const localLog = [];
             const result = await callback({
                 nodeId: this.nodeId,
                 retry: this.retryCount,
                 params: this.params,
                 inputs: results,
                 forkIndex: this.forkIndex,
+                verbose: this.graph.verbose,
+                agents: this.graph.callbackDictonary,
+                log: localLog,
             });
             if (this.transactionId !== transactionId) {
                 console.log(`-- ${this.nodeId}: transactionId mismatch`);
@@ -124,11 +158,20 @@ class Node {
             }
             log.endTime = Date.now();
             log.result = result;
+            if (localLog.length > 0) {
+                log.log = localLog;
+            }
             const outputs = this.outputs;
             if (outputs !== undefined) {
-                Object.keys(result).forEach((outputId) => {
+                Object.keys(outputs).forEach((outputId) => {
                     const nodeId = outputs[outputId];
-                    this.graph.injectResult(nodeId, result[outputId]);
+                    const value = result[outputId];
+                    if (value) {
+                        this.graph.injectValue(nodeId, value);
+                    }
+                    else {
+                        console.error("-- Invalid outputId", outputId, result);
+                    }
                 });
                 log.state = NodeState.Dispatched;
                 this.state = NodeState.Dispatched;
@@ -160,20 +203,10 @@ 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;
-        this.concurrency = data.concurrency ?? defaultConcurrency;
-        this.onComplete = () => {
-            console.error("-- SOMETHING IS WRONG: onComplete is called without run()");
-        };
+    createNodes(data) {
         const nodeId2forkedNodeIds = {};
         const forkedNodeId2Index = {};
-        // Create node instances from data.nodes
-        this.nodes = Object.keys(data.nodes).reduce((nodes, nodeId) => {
+        const nodes = Object.keys(data.nodes).reduce((nodes, nodeId) => {
             const fork = data.nodes[nodeId].fork;
             if (fork) {
                 // For fork, change the nodeId and increase the node
@@ -191,8 +224,8 @@ class GraphAI {
             return nodes;
         }, {});
         // Generate the waitlist for each node, and update the pendings in case of forked node.
-        Object.keys(this.nodes).forEach((nodeId) => {
-            const node = this.nodes[nodeId];
+        Object.keys(nodes).forEach((nodeId) => {
+            const node = nodes[nodeId];
             node.pendings.forEach((pending) => {
                 // If the pending(previous) node is forking
                 if (nodeId2forkedNodeIds[pending]) {
@@ -200,36 +233,74 @@ class GraphAI {
                     if (node.fork) {
                         //  1:1 if current nodes are also forking.
                         const newPendingId = nodeId2forkedNodeIds[pending][forkedNodeId2Index[nodeId]];
-                        this.nodes[newPendingId].waitlist.add(nodeId); // previousNode
+                        nodes[newPendingId].waitlist.add(nodeId); // previousNode
                         node.pendings.add(newPendingId);
                     }
                     else {
                         //  1:n if current node is not forking.
                         nodeId2forkedNodeIds[pending].forEach((newPendingId) => {
-                            this.nodes[newPendingId].waitlist.add(nodeId); // previousNode
+                            nodes[newPendingId].waitlist.add(nodeId); // previousNode
                             node.pendings.add(newPendingId);
                         });
                     }
                     node.pendings.delete(pending);
                 }
                 else {
-                    this.nodes[pending].waitlist.add(nodeId); // previousNode
+                    if (nodes[pending]) {
+                        nodes[pending].waitlist.add(nodeId); // previousNode
+                    }
+                    else {
+                        console.error(`--- invalid input ${pending} for node, ${nodeId}`);
+                    }
                 }
             });
             node.inputs = Array.from(node.pendings); // for fork.
         });
+        return nodes;
+    }
+    getValueFromResults(key, results) {
+        const { sourceNodeId, propId } = parseNodeName(key);
+        const result = results[sourceNodeId];
+        return result ? (propId ? result[propId] : result) : undefined;
+    }
+    initializeNodes(previousResults) {
         // If the result property is specified, inject it.
-        // NOTE: This must be done at the end of this constructor
-        Object.keys(data.nodes).forEach((nodeId) => {
-            const result = data.nodes[nodeId].result;
-            if (result) {
-                this.injectResult(nodeId, result);
+        // If the previousResults exists (indicating we are in a loop),
+        // process the next property (nodeId or nodeId.propId).
+        Object.keys(this.data.nodes).forEach((nodeId) => {
+            const node = this.data.nodes[nodeId];
+            const { value, next } = node;
+            if (value) {
+                this.injectValue(nodeId, value);
+            }
+            if (next && previousResults) {
+                const result = this.getValueFromResults(next, previousResults);
+                if (result) {
+                    this.injectValue(nodeId, result);
+                }
             }
         });
     }
-    getCallback(_agentId) {
-        const agentId = _agentId ?? "_default";
-        if (this.callbackDictonary[agentId]) {
+    constructor(data, callbackDictonary) {
+        this.isRunning = false;
+        this.runningNodes = new Set();
+        this.nodeQueue = [];
+        this.repeatCount = 0;
+        this.logs = [];
+        this.data = data;
+        this.callbackDictonary = callbackDictonary;
+        this.concurrency = data.concurrency ?? defaultConcurrency;
+        this.loop = data.loop;
+        this.agentId = data.agentId;
+        this.verbose = data.verbose === true;
+        this.onComplete = () => {
+            console.error("-- SOMETHING IS WRONG: onComplete is called without run()");
+        };
+        this.nodes = this.createNodes(data);
+        this.initializeNodes();
+    }
+    getCallback(agentId) {
+        if (agentId && this.callbackDictonary[agentId]) {
             return this.callbackDictonary[agentId];
         }
         throw new Error("No agent: " + agentId);
@@ -259,16 +330,19 @@ class GraphAI {
             return errors;
         }, {});
     }
-    async run() {
-        if (this.isRunning) {
-            console.error("-- Already Running");
-        }
-        this.isRunning = true;
+    pushReadyNodesIntoQueue() {
         // Nodes without pending data should run immediately.
         Object.keys(this.nodes).forEach((nodeId) => {
             const node = this.nodes[nodeId];
             node.pushQueueIfReady();
         });
+    }
+    async run() {
+        if (this.isRunning) {
+            console.error("-- Already Running");
+        }
+        this.isRunning = true;
+        this.pushReadyNodesIntoQueue();
         return new Promise((resolve, reject) => {
             this.onComplete = () => {
                 this.isRunning = false;
@@ -304,6 +378,27 @@ class GraphAI {
             }
         }
         if (this.runningNodes.size === 0) {
+            this.repeatCount++;
+            const loop = this.loop;
+            if (loop && (loop.count === undefined || this.repeatCount < loop.count)) {
+                const results = this.results(); // results from previous loop
+                this.isRunning = false; // temporarily stop it
+                this.nodes = this.createNodes(this.data);
+                this.initializeNodes(results);
+                const checkWhileCondition = () => {
+                    if (loop.while) {
+                        const value = this.getValueFromResults(loop.while, this.results());
+                        // NOTE: We treat an empty array as false.
+                        return Array.isArray(value) ? value.length > 0 : !!value;
+                    }
+                    return true;
+                };
+                if (checkWhileCondition()) {
+                    this.isRunning = true; // restore it
+                    this.pushReadyNodesIntoQueue();
+                    return;
+                }
+            }
             this.onComplete();
         }
     }
@@ -313,10 +408,10 @@ class GraphAI {
     transactionLogs() {
         return this.logs;
     }
-    injectResult(nodeId, result) {
+    injectValue(nodeId, value) {
         const node = this.nodes[nodeId];
         if (node) {
-            node.injectResult(result);
+            node.injectValue(value);
         }
         else {
             console.error("-- Invalid nodeId", nodeId);

package/lib/graphai_cli.js

@@ -9,7 +9,7 @@ const experimental_agents_1 = require("./experimental_agents");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const yaml_1 = __importDefault(require("yaml"));
-const testAgent = async (context) => {
+const testAgent = async () => {
     return {};
 };
 const main = async () => {

package/lib/utils/utils.d.ts

@@ -0,0 +1 @@
+export declare const sleep: (milliseconds: number) => Promise<unknown>;

package/lib/utils/utils.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = void 0;
+const sleep = async (milliseconds) => {
+    return await new Promise((resolve) => setTimeout(resolve, milliseconds));
+};
+exports.sleep = sleep;

package/package.json

@@ -1,15 +1,21 @@
 {
   "name": "graphai",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "Asynchronous data flow execution engine to make it simple to build LLM apps.",
   "main": "lib/index.js",
-  "bin": "lib/graphai_cli.js",
+  "bin": {
+    "graphai": "lib/graphai_cli.js"
+  },
+  "files": [
+    "./lib"
+  ],
   "scripts": {
     "build": "tsc && tsc-alias",
-    "eslint": "eslint --fix --ext src/**/*.{ts} tests/**/*.ts",
+    "eslint": "eslint --fix --ext .ts ./src ./tests ./samples",
     "format": "prettier --write '{src,tests,samples}/**/*.ts' .eslintrc.js",
     "test": "node --test  -r tsconfig-paths/register --require ts-node/register ./tests/**/test_*.ts",
     "cli": "npx ts-node  -r tsconfig-paths/register ./src/graphai_cli.ts",
+    "samples": "npx ts-node  -r tsconfig-paths/register samples/sample_runner.ts",
     "sample": "npx ts-node  -r tsconfig-paths/register"
   },
   "repository": {
@@ -23,11 +29,14 @@
   },
   "homepage": "https://github.com/snakajima/graphai#readme",
   "devDependencies": {
+    "@inquirer/prompts": "^5.0.0",
     "@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",
+    "deepmerge": "^4.3.1",
+    "dotenv": "^16.4.5",
     "eslint": "^7.32.0 || ^8.2.0",
     "eslint-plugin-import": "^2.25.2",
     "express": "^4.19.2",
@@ -37,7 +46,8 @@
     "ts-node": "^10.9.1",
     "tsc-alias": "^1.8.8",
     "tsconfig-paths": "^4.2.0",
-    "typescript": "^5.2.2"
+    "typescript": "^5.2.2",
+    "wikipedia": "^2.1.2"
   },
   "dependencies": {
     "yaml": "^2.3.3"

package/.eslintrc.js

@@ -1,30 +0,0 @@
-module.exports = {
-  env: {
-    es2021: true,
-    node: true,
-  },
-  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"],
-  },
-};

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

@@ -1,28 +0,0 @@
-# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
-# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
-
-name: Node.js CI
-
-on:
-  pull_request
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [18.x, 20.x]
-        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
-
-    steps:
-    - uses: actions/checkout@v4
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v4
-      with:
-        node-version: ${{ matrix.node-version }}
-        cache: 'npm'
-    - run: yarn install
-    - run: cd tests/http-server/docs/ && npx http-server &
-    - run: yarn test

package/.prettierrc

@@ -1,3 +0,0 @@
-{
-  "printWidth": 160
-}

package/samples/agents/arxiv_agent.ts

@@ -1,45 +0,0 @@
-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<{}, Record<string, any>, string[]> = async (context) => {
-  const result = (context.inputs[0] || [])
-    .map((r: any) => {
-      const { id, title, summary } = r;
-      return ["id:", id, "title:", title, "summary:", summary].join("\n");
-    })
-    .join("\n\n\n");
-  return { content: result };
-};

package/samples/agents/parroting_agent.ts

@@ -1,5 +0,0 @@
-import { AgentFunction } from "@/graphai";
-
-export const parrotingAgent: AgentFunction = async (context) => {
-  return context.params;
-};

package/samples/agents/slashgpt_agent.ts

@@ -1,19 +0,0 @@
-import path from "path";
-import { AgentFunction } from "@/graphai";
-import { ChatSession, ChatConfig, ManifestData } from "slashgpt";
-
-const config = new ChatConfig(path.resolve(__dirname));
-
-export const slashGPTFuncitons2TextAgent: AgentFunction<
-  { function_data_key: string; result_key: number },
-  Record<string, string>,
-  { function_data: { [key: string]: string[] } }
-> = async (context) => {
-  const { params } = context;
-  const result = (context?.inputs[0].function_data[params.function_data_key] || []).map((r: any) => {
-    const { title, description } = r;
-    return ["title:", title, "description:", description].join("\n");
-  });
-
-  return { content: result[context.forkIndex ?? 0] };
-};

package/samples/express.ts

@@ -1,47 +0,0 @@
-//  npx ts-node samples/express.ts
-import { GraphAI, AgentFunction } from "@/graphai";
-
-import express from "express";
-
-const app = express();
-
-const graphAISample = async (req: express.Request, res: express.Response) => {
-  const graph_data = {
-    nodes: {
-      node1: {
-        params: {},
-      },
-    },
-    concurrency: 8,
-  };
-  const testFunction: AgentFunction<Record<string, string>> = async (context) => {
-    console.log("hello");
-    return {};
-  };
-  const graph = new GraphAI(graph_data, testFunction);
-  const response = await graph.run();
-  res.json({ result: response });
-  res.end();
-};
-
-const hello = async (req: express.Request, res: express.Response) => {
-  const { params, query } = req;
-  res.json({
-    result: [
-      {
-        message: "hello",
-        params,
-        query,
-      },
-    ],
-  });
-  res.end();
-};
-
-app.use(express.json());
-app.get("/", hello);
-app.get("/mock", graphAISample);
-
-const server = app.listen(8080, () => {
-  console.log("Running Server");
-});

package/samples/graphs/arxiv.yml

@@ -1,25 +0,0 @@
-nodes:
-  searchArxiv:
-    params:
-      keywords:
-        - llm
-        - gpt
-      limit: 10
-    agentId: arxivAgent
-  arxiv2TextAgent:
-    inputs: [searchArxiv]
-    agentId: arxiv2TextAgent
-  slashGPTAgent:
-    inputs: [arxiv2TextAgent]
-    agentId: slashGPTAgent
-    params:
-      query: |
-        与えられたそれぞれの論文の要点をまとめ、以下の項目で日本語で出力せよ。それぞれの項目は最大でも180文字以内に要約せよ。
-        ```
-        論文名:タイトルの日本語訳
-        キーワード:この論文のキーワード
-        課題:この論文が解決する課題
-        手法:この論文が提案する手法,
-        結果:提案手法によって得られた結果
-        ```
-      

package/samples/graphs/slash_gpt.yml

@@ -1,28 +0,0 @@
-nodes:
-  node1:
-    agentId: slashgpt
-    params:
-      query: Come up with ten business ideas for AI startup
-  node2:
-    agentId: stringTemplate
-    inputs: [node1]
-    params:
-      template: |
-        Please evaluate following business ideas.
-        ${0}
-  node3:
-    agentId: slashgpt
-    inputs: [node2]
-  node4:
-    agentId: stringTemplate
-    inputs: [node1, node3]
-    params:
-      template:  |
-        Please pick the winner of this business idea contest.
-        [ideas]
-        ${0}
-        [evalutations]
-        ${1}
-  node5:
-    agentId: slashgpt
-    inputs: [node4]