graphai 0.0.9 → 0.0.11

package/samples/interaction.ts

@@ -1,49 +0,0 @@
-import { GraphAI, GraphData } from "@/graphai";
-import * as readline from "readline";
-import path from "path";
-import * as fs from "fs";
-import { testAgent } from "~/agents/agents";
-
-const getUserInput = async (question: string): Promise<string> => {
-  return new Promise((resolve, reject) => {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-    });
-
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(answer);
-    });
-  });
-};
-
-const graph_data: GraphData = {
-  nodes: {
-    node1: {
-      source: true,
-    },
-    node2: {
-      inputs: ["node1"],
-    },
-  },
-};
-
-const runAgent = async (query: string) => {
-  console.log("query=", query);
-  graph_data.nodes.node1.result = { query };
-  const graph = new GraphAI(graph_data, testAgent);
-  // graph.injectResult("node1", { query });
-  const result = await graph.run();
-  const log_path = path.resolve(__dirname) + "/../tests/logs/interaction.log";
-  fs.writeFileSync(log_path, JSON.stringify(graph.transactionLogs(), null, 2));
-  console.log(result);
-};
-
-const main = async () => {
-  const query = await getUserInput("Please enter your question: ");
-  await runAgent(query);
-  console.log("COMPLETE 1");
-};
-
-main();

package/samples/sample_co2.ts

@@ -1,85 +0,0 @@
-import { GraphAI, AgentFunction } from "@/graphai";
-import { readGraphaiData } from "~/utils/file_utils";
-
-import { slashGPTAgent, slashGPTFuncitons2TextAgent } from "./agents/slashgpt_agent";
-
-const graph_data = {
-  nodes: {
-    slashGPTAgent: {
-      agentId: "slashGPTAgent",
-      params: {
-        function_result: true,
-        prompt: "世界で協力してco2を減らす方法を教えて下さい",
-        manifest: {
-          prompt: "あなたは世界経済の専門家です。ユーザの問い合わせについて考え、10この結果をfunctionsの結果に返してください。",
-          skip_function_result: true,
-          actions: {
-            your_ideas: {
-              type: "message_template",
-              message: "dummy",
-            },
-          },
-          functions: [
-            {
-              name: "your_ideas",
-              description: "Your answer to a user's inquiry",
-              parameters: {
-                type: "object",
-                properties: {
-                  methods: {
-                    type: "array",
-                    items: {
-                      type: "object",
-                      properties: {
-                        title: {
-                          type: "string",
-                          description: "title",
-                        },
-                        description: {
-                          type: "string",
-                          description: "description",
-                        },
-                      },
-                      required: ["title", "description"],
-                    },
-                  },
-                },
-              },
-            },
-          ],
-        },
-      },
-    },
-    function2prompt0: {
-      fork: 10,
-      params: {
-        function_data_key: "methods",
-        result_key: 0,
-      },
-      inputs: ["slashGPTAgent"],
-      agentId: "slashGPTFuncitons2TextAgent",
-    },
-    slashGPTAgent0: {
-      agentId: "slashGPTAgent",
-      fork: 10,
-      params: {
-        debug: true,
-        manifest: {
-          prompt: "ユーザの問い合わせにある文章の専門家です。専門家として、ユーザのアイデアに対して実現可能なシナリオを800文字で書いてください。",
-        },
-      },
-      inputs: ["function2prompt0"],
-    },
-  },
-};
-const runAgent = async () => {
-  const graph = new GraphAI(graph_data, { slashGPTAgent, slashGPTFuncitons2TextAgent });
-  const result = await graph.run();
-  console.log(result);
-};
-
-const main = async () => {
-  await runAgent();
-  console.log("COMPLETE 1");
-};
-main();

package/samples/sample_gpt.ts

@@ -1,40 +0,0 @@
-import path from "path";
-import * as fs from "fs";
-import { GraphAI, AgentFunction } from "@/graphai";
-import { ChatSession, ChatConfig, ManifestData } from "slashgpt";
-import { readGraphaiData } from "~/utils/file_utils";
-
-const config = new ChatConfig(path.resolve(__dirname));
-
-const slashGPTAgent: AgentFunction<{ manifest: ManifestData; prompt: string }, { content: string }> = async (context) => {
-  console.log("executing", context.nodeId, context.params);
-  const session = new ChatSession(config, context.params.manifest ?? {});
-  const prompt = context.inputs.reduce((prompt, input, index) => {
-    return prompt.replace("${" + index + "}", input["content"]);
-  }, context.params.prompt);
-  session.append_user_question(prompt);
-
-  await session.call_loop(() => {});
-  const message = session.history.last_message();
-  if (message === undefined) {
-    throw new Error("No message in the history");
-  }
-  return message;
-};
-
-const runAgent = async (file: string) => {
-  const file_path = path.resolve(__dirname) + file;
-  const graph_data = readGraphaiData(file_path);
-  const graph = new GraphAI(graph_data, slashGPTAgent);
-  const results = (await graph.run()) as Record<string, any>;
-
-  const log_path = path.resolve(__dirname) + "/../tests/logs/" + path.basename(file_path).replace(/\.yml$/, ".log");
-  console.log(log_path);
-  fs.writeFileSync(log_path, JSON.stringify(graph.transactionLogs(), null, 2));
-  console.log(results["node3"]["content"]);
-};
-
-const main = async () => {
-  await runAgent("/graphs/slash_gpt.yml");
-};
-main();

package/samples/sample_paper_ai.ts

@@ -1,22 +0,0 @@
-import path from "path";
-import search from "arXiv-api-ts";
-
-import { GraphAI, AgentFunction } from "@/graphai";
-import { readGraphaiData } from "~/utils/file_utils";
-
-import { slashGPTAgent } from "./agents/slashgpt_agent";
-import { arxivAgent, arxiv2TextAgent } from "./agents/arxiv_agent";
-
-const runAgent = async (file: string) => {
-  const file_path = path.resolve(__dirname) + file;
-  const graph_data = readGraphaiData(file_path);
-  const graph = new GraphAI(graph_data, { arxivAgent: arxivAgent, arxiv2TextAgent, slashGPTAgent });
-  const result = await graph.run();
-  console.log(result);
-};
-
-const main = async () => {
-  await runAgent("/graphs/arxiv.yml");
-  console.log("COMPLETE 1");
-};
-main();

package/src/graphai.ts

@@ -1,417 +0,0 @@
-export enum NodeState {
-  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; // Agent-specific parameters
-
-type NodeData = {
-  inputs?: Array<string>;
-  params?: NodeDataParams;
-  retry?: number;
-  timeout?: number; // msec
-  agentId?: string;
-  fork?: number;
-  source?: boolean;
-  result?: ResultData; // preset result for source node.
-  outputs?: Record<string, string>; // mapping from routeId to nodeId
-};
-
-export type GraphData = {
-  nodes: Record<string, NodeData>;
-  concurrency?: number;
-};
-
-export type TransactionLog = {
-  nodeId: string;
-  state: NodeState;
-  startTime: number;
-  endTime?: number;
-  retryCount: number;
-  agentId?: string;
-  params?: NodeDataParams;
-  inputs?: Array<ResultData>;
-  errorMessage?: string;
-  result?: ResultData;
-};
-
-export type AgentFunctionContext<ParamsType, ResultType, PreviousResultType> = {
-  nodeId: string;
-  forkIndex?: number;
-  retry: number;
-  params: NodeDataParams<ParamsType>;
-  inputs: Array<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>>;
-
-class Node {
-  public nodeId: string;
-  public params: NodeDataParams; // Agent-specific parameters
-  public inputs: Array<string>; // List of nodes this node needs data from.
-  public pendings: Set<string>; // List of nodes this node is waiting data from.
-  public waitlist = new Set<string>(); // List of nodes which need data from this node.
-  public state = NodeState.Waiting;
-  public agentId?: string;
-  public fork?: number;
-  public forkIndex?: number;
-  public result: ResultData = undefined;
-  public retryLimit: number;
-  public retryCount: number = 0;
-  public transactionId: undefined | number; // To reject callbacks from timed-out transactions
-  public timeout?: number; // msec
-  public error?: Error;
-  public source: boolean;
-  public outputs?: Record<string, string>; // Mapping from routeId to nodeId
-
-  private graph: GraphAI;
-
-  constructor(nodeId: string, forkIndex: number | undefined, data: NodeData, graph: GraphAI) {
-    this.nodeId = nodeId;
-    this.forkIndex = forkIndex;
-    this.inputs = data.inputs ?? [];
-    this.pendings = new Set(this.inputs);
-    this.params = data.params ?? {};
-    this.agentId = data.agentId;
-    this.fork = data.fork;
-    this.retryLimit = data.retry ?? 0;
-    this.timeout = data.timeout;
-    this.source = data.source === true;
-    this.outputs = data.outputs;
-    this.graph = graph;
-  }
-
-  public asString() {
-    return `${this.nodeId}: ${this.state} ${[...this.waitlist]}`;
-  }
-
-  private retry(state: NodeState, error: Error) {
-    if (this.retryCount < this.retryLimit) {
-      this.retryCount++;
-      this.execute();
-    } else {
-      this.state = state;
-      this.result = undefined;
-      this.error = error;
-      this.transactionId = undefined; // This is necessary for timeout case
-      this.graph.removeRunning(this);
-    }
-  }
-
-  public removePending(nodeId: string) {
-    this.pendings.delete(nodeId);
-    if (this.graph.isRunning) {
-      this.pushQueueIfReady();
-    }
-  }
-
-  public pushQueueIfReady() {
-    if (this.pendings.size === 0 && !this.source) {
-      this.graph.pushQueue(this);
-    }
-  }
-
-  public injectResult(result: ResultData) {
-    if (this.source) {
-      const log: TransactionLog = {
-        nodeId: this.nodeId,
-        retryCount: this.retryCount,
-        state: NodeState.Injected,
-        startTime: Date.now(),
-        endTime: Date.now(),
-        result,
-      };
-      this.graph.appendLog(log);
-      this.setResult(result, NodeState.Injected);
-    } else {
-      console.error("- injectResult called on non-source node.", this.nodeId);
-    }
-  }
-
-  private setResult(result: ResultData, state: NodeState) {
-    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);
-    });
-  }
-
-  public async execute() {
-    const results = this.graph.resultsOf(this.inputs);
-    const transactionId = Date.now();
-    const log: TransactionLog = {
-      nodeId: this.nodeId,
-      retryCount: this.retryCount,
-      state: NodeState.Executing,
-      startTime: transactionId,
-      agentId: this.agentId,
-      params: this.params,
-      inputs: results,
-    };
-    this.graph.appendLog(log);
-    this.state = NodeState.Executing;
-    this.transactionId = transactionId;
-
-    if (this.timeout && this.timeout > 0) {
-      setTimeout(() => {
-        if (this.state === NodeState.Executing && this.transactionId === transactionId) {
-          console.log(`-- ${this.nodeId}: timeout ${this.timeout}`);
-          log.errorMessage = "Timeout";
-          log.state = NodeState.TimedOut;
-          log.endTime = Date.now();
-          this.retry(NodeState.TimedOut, Error("Timeout"));
-        }
-      }, this.timeout);
-    }
-
-    try {
-      const callback = this.graph.getCallback(this.agentId);
-      const result = await callback({
-        nodeId: this.nodeId,
-        retry: this.retryCount,
-        params: this.params,
-        inputs: results,
-        forkIndex: this.forkIndex,
-      });
-      if (this.transactionId !== transactionId) {
-        console.log(`-- ${this.nodeId}: transactionId mismatch`);
-        return;
-      }
-
-      log.endTime = Date.now();
-      log.result = result;
-
-      const outputs = this.outputs;
-      if (outputs !== undefined) {
-        Object.keys(result).forEach((outputId) => {
-          const nodeId = outputs[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) {
-      if (this.transactionId !== transactionId) {
-        console.log(`-- ${this.nodeId}: transactionId mismatch(error)`);
-        return;
-      }
-      log.state = NodeState.Failed;
-      log.endTime = Date.now();
-      if (error instanceof Error) {
-        log.errorMessage = error.message;
-        this.retry(NodeState.Failed, error);
-      } else {
-        console.error(`-- ${this.nodeId}: Unexpecrted error was caught`);
-        log.errorMessage = "Unknown";
-        this.retry(NodeState.Failed, Error("Unknown"));
-      }
-    }
-  }
-}
-
-type GraphNodes = Record<string, Node>;
-
-const defaultConcurrency = 8;
-
-export class GraphAI {
-  public nodes: GraphNodes;
-  public callbackDictonary: AgentFunctionDictonary;
-  public isRunning = false;
-  private runningNodes = new Set<string>();
-  private nodeQueue: Array<Node> = [];
-  private onComplete: () => void;
-  private concurrency: number;
-  private logs: Array<TransactionLog> = [];
-
-  constructor(data: GraphData, callbackDictonary: AgentFunctionDictonary | AgentFunction<any, any, any>) {
-    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()");
-    };
-    const nodeId2forkedNodeIds: Record<string, string[]> = {};
-    const forkedNodeId2Index: Record<string, number> = {};
-
-    // Create node instances from data.nodes
-    this.nodes = Object.keys(data.nodes).reduce((nodes: GraphNodes, nodeId: string) => {
-      const fork = data.nodes[nodeId].fork;
-      if (fork) {
-        // For fork, change the nodeId and increase the node
-        nodeId2forkedNodeIds[nodeId] = new Array(fork).fill(undefined).map((_, i) => {
-          const forkedNodeId = `${nodeId}_${i}`;
-          nodes[forkedNodeId] = new Node(forkedNodeId, i, data.nodes[nodeId], this);
-          // Data for pending and waiting
-          forkedNodeId2Index[forkedNodeId] = i;
-          return forkedNodeId;
-        });
-      } else {
-        nodes[nodeId] = new Node(nodeId, undefined, data.nodes[nodeId], this);
-      }
-      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];
-      node.pendings.forEach((pending) => {
-        // If the pending(previous) node is forking
-        if (nodeId2forkedNodeIds[pending]) {
-          //  update node.pending and pending(previous) node.wailtlist
-          if (node.fork) {
-            //  1:1 if current nodes are also forking.
-            const newPendingId = nodeId2forkedNodeIds[pending][forkedNodeId2Index[nodeId]];
-            this.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
-              node.pendings.add(newPendingId);
-            });
-          }
-          node.pendings.delete(pending);
-        } else {
-          this.nodes[pending].waitlist.add(nodeId); // previousNode
-        }
-      });
-      node.inputs = Array.from(node.pendings); // for fork.
-    });
-
-    // 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);
-      }
-    });
-  }
-
-  public getCallback(_agentId?: string) {
-    const agentId = _agentId ?? "_default";
-    if (this.callbackDictonary[agentId]) {
-      return this.callbackDictonary[agentId];
-    }
-    throw new Error("No agent: " + agentId);
-  }
-
-  public asString() {
-    return Object.keys(this.nodes)
-      .map((nodeId) => {
-        return this.nodes[nodeId].asString();
-      })
-      .join("\n");
-  }
-
-  public results() {
-    return Object.keys(this.nodes).reduce((results: ResultDataDictonary, nodeId) => {
-      const node = this.nodes[nodeId];
-      if (node.result !== undefined) {
-        results[nodeId] = node.result;
-      }
-      return results;
-    }, {});
-  }
-
-  public errors() {
-    return Object.keys(this.nodes).reduce((errors: Record<string, Error>, nodeId) => {
-      const node = this.nodes[nodeId];
-      if (node.error !== undefined) {
-        errors[nodeId] = node.error;
-      }
-      return errors;
-    }, {});
-  }
-
-  public 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];
-      node.pushQueueIfReady();
-    });
-
-    return new Promise((resolve, reject) => {
-      this.onComplete = () => {
-        this.isRunning = false;
-        const errors = this.errors();
-        const nodeIds = Object.keys(errors);
-        if (nodeIds.length > 0) {
-          reject(errors[nodeIds[0]]);
-        } else {
-          resolve(this.results());
-        }
-      };
-    });
-  }
-
-  private runNode(node: Node) {
-    this.runningNodes.add(node.nodeId);
-    node.execute();
-  }
-
-  public pushQueue(node: Node) {
-    if (this.runningNodes.size < this.concurrency) {
-      this.runNode(node);
-    } else {
-      this.nodeQueue.push(node);
-    }
-  }
-
-  public removeRunning(node: Node) {
-    this.runningNodes.delete(node.nodeId);
-    if (this.nodeQueue.length > 0) {
-      const n = this.nodeQueue.shift();
-      if (n) {
-        this.runNode(n);
-      }
-    }
-    if (this.runningNodes.size === 0) {
-      this.onComplete();
-    }
-  }
-
-  public appendLog(log: TransactionLog) {
-    this.logs.push(log);
-  }
-
-  public transactionLogs() {
-    return this.logs;
-  }
-
-  public injectResult(nodeId: string, result: ResultData) {
-    const node = this.nodes[nodeId];
-    if (node) {
-      node.injectResult(result);
-    } else {
-      console.error("-- Invalid nodeId", nodeId);
-    }
-  }
-
-  public resultsOf(nodeIds: Array<string>) {
-    return nodeIds.map((nodeId) => {
-      return this.nodes[nodeId].result;
-    });
-  }
-}

package/src/graphai_cli.ts

@@ -1,35 +0,0 @@
-#!/usr/bin/env node
-
-import { GraphAI, AgentFunction } from "./graphai";
-import fs from "fs";
-import path from "path";
-import YAML from "yaml";
-
-const testAgent: AgentFunction<{ delay: number; fail: boolean }> = async (context) => {
-  return {};
-};
-
-const main = async () => {
-  const file = process.argv[2];
-  if (file === undefined) {
-    console.log("no file");
-    return;
-  }
-  const file_path = path.resolve(process.cwd() + "/" + file);
-  if (!fs.existsSync(file_path)) {
-    console.log("no file");
-    return;
-  }
-  try {
-    const graph_data_file = fs.readFileSync(file_path, "utf8");
-    const graph_data = YAML.parse(graph_data_file);
-
-    const graph = new GraphAI(graph_data, { test: testAgent });
-    const results = await graph.run();
-    console.log(results);
-  } catch (e) {
-    console.log("error", e);
-  }
-};
-
-main();

package/src/index.ts

@@ -1,3 +0,0 @@
-import { GraphAI } from "./graphai";
-
-export { GraphAI };

package/tests/agents/agents.ts

@@ -1,23 +0,0 @@
-import { AgentFunction } from "@/graphai";
-import { sleep } from "~/utils/utils";
-
-export const testAgent: AgentFunction<{ delay: number; fail: boolean }> = async (context) => {
-  const { nodeId, retry, params, inputs } = context;
-  console.log("executing", nodeId);
-  await sleep(params.delay / (retry + 1));
-
-  if (params.fail && retry < 2) {
-    const result = { [nodeId]: "failed" };
-    console.log("failed (intentional)", nodeId, retry);
-    throw new Error("Intentional Failure");
-  } else {
-    const result = inputs.reduce(
-      (result: Record<string, any>, input: Record<string, any>) => {
-        return { ...result, ...input };
-      },
-      { [nodeId]: "output" },
-    );
-    console.log("completing", nodeId);
-    return result;
-  }
-};