implement base agents

package.json

@@ -3,6 +3,7 @@
   "version": "0.0.1",
   "description": "Projeto de TALP 1",
   "main": "dist/index.js",
+  "type": "module",
   "scripts": {
     "test": "vitest",
     "coverage": "vitest run --coverage",

src/agents/auditor/agent.ts

@@ -0,0 +1,20 @@
+import { END, type GraphNode, START, StateGraph } from "@langchain/langgraph";
+
+import { AuditorState } from "./state.ts";
+import { slitherTool } from "./tools/slither-tool.ts";
+
+const PLACEHOLDER_VULNERABILITIES = [
+  { type: "reentrancy", severity: "high", description: "Unchecked external call allows reentrancy attack." },
+  { type: "integer-overflow", severity: "medium", description: "Arithmetic operation may overflow." },
+];
+
+const auditContract: GraphNode<typeof AuditorState> = async (state) => {
+  await slitherTool.invoke({ solidityFile: state.solidityFile });
+  return { vulnerabilities: PLACEHOLDER_VULNERABILITIES };
+};
+
+export const auditorAgent = new StateGraph(AuditorState)
+  .addNode("auditContract", auditContract)
+  .addEdge(START, "auditContract")
+  .addEdge("auditContract", END)
+  .compile();

src/agents/auditor/index.ts

@@ -1,62 +0,0 @@
-import { AIMessage, SystemMessage, type ToolMessage } from "@langchain/core/messages";
-import { type ConditionalEdgeRouter, END, type GraphNode, START, StateGraph } from "@langchain/langgraph";
-import { model } from "./model";
-import { MessagesState } from "./state";
-import { searchTool } from "./tools/search-tool";
-
-const modelWithTools = model.bindTools([searchTool]);
-
-const llmCall: GraphNode<typeof MessagesState> = async (state) => {
-  return {
-    messages: [
-      await modelWithTools.invoke([
-        new SystemMessage("You are a helpful assistant tasked with performing arithmetic on a set of inputs."),
-        ...state.messages,
-      ]),
-    ],
-    llmCalls: 1,
-  };
-};
-
-const toolNode: GraphNode<typeof MessagesState> = async (state) => {
-  const lastMessage = state.messages.at(-1);
-
-  if (lastMessage == null || !AIMessage.isInstance(lastMessage)) {
-    return { messages: [] };
-  }
-
-  const result: ToolMessage[] = [];
-  for (const toolCall of lastMessage.tool_calls ?? []) {
-    const _toolName = toolCall.name;
-    const tool = searchTool;
-    const observation = await tool.invoke(toolCall);
-    result.push(observation);
-  }
-
-  return { messages: result };
-};
-
-const shouldContinue: ConditionalEdgeRouter<typeof MessagesState, {}, "toolNode"> = (state) => {
-  const lastMessage = state.messages.at(-1);
-
-  // Check if it's an AIMessage before accessing tool_calls
-  if (!lastMessage || !AIMessage.isInstance(lastMessage)) {
-    return END;
-  }
-
-  // If the LLM makes a tool call, then perform an action
-  if (lastMessage.tool_calls?.length) {
-    return "toolNode";
-  }
-
-  // Otherwise, we stop (reply to the user)
-  return END;
-};
-
-export const agent = new StateGraph(MessagesState)
-  .addNode("llmCall", llmCall)
-  .addNode("toolNode", toolNode)
-  .addEdge(START, "llmCall")
-  .addConditionalEdges("llmCall", shouldContinue, ["toolNode", END])
-  .addEdge("toolNode", "llmCall")
-  .compile();

src/agents/auditor/model.ts

@@ -1,5 +1,5 @@
 import { ChatOpenRouter } from "@langchain/openrouter";
 
-export const model = new ChatOpenRouter({
-  model: "claude-3-7-sonnet-latest",
+export const auditorModel = new ChatOpenRouter({
+  model: "moonshotai/kimi-k2.6",
 });

src/agents/auditor/state.ts

@@ -1,7 +1,7 @@
-import { MessagesValue, ReducedValue, StateSchema } from "@langchain/langgraph";
+import { StateSchema } from "@langchain/langgraph";
 import { z } from "zod";
 
-export const MessagesState = new StateSchema({
-  messages: MessagesValue,
-  llmCalls: new ReducedValue(z.number().default(0), { reducer: (x, y) => x + y }),
+export const AuditorState = new StateSchema({
+  solidityFile: z.string().default(""),
+  vulnerabilities: z.array(z.record(z.string(), z.any())).default([]),
 });

src/agents/auditor/tools/search-tool.ts

@@ -1,18 +0,0 @@
-import { tool } from "langchain";
-import { z } from "zod";
-
-export const searchTool = tool(
-  async ({ query }) => {
-    if (query.toLowerCase().includes("sf") || query.toLowerCase().includes("san francisco")) {
-      return "It's 60 degrees and foggy.";
-    }
-    return "It's 90 degrees and sunny.";
-  },
-  {
-    name: "search",
-    description: "Call to surf the web.",
-    schema: z.object({
-      query: z.string().describe("The query to use in your search."),
-    }),
-  },
-);

src/agents/auditor/tools/slither-tool.ts

@@ -0,0 +1,15 @@
+import { tool } from "langchain";
+import { z } from "zod";
+
+export const slitherTool = tool(
+  async (_input) => {
+    return [];
+  },
+  {
+    name: "slither",
+    description: "Run slither static analysis on a Solidity contract.",
+    schema: z.object({
+      solidityFile: z.string().describe("The Solidity source code to analyze."),
+    }),
+  },
+);

src/agents/coder/agent.ts

@@ -0,0 +1,20 @@
+import { END, type GraphNode, START, StateGraph } from "@langchain/langgraph";
+
+import { CoderState } from "./state.ts";
+
+const PLACEHOLDER_CONTRACT = `// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract Placeholder {
+    // TODO: implement contract based on requirements
+}`;
+
+const generateContract: GraphNode<typeof CoderState> = async (_state) => {
+  return { contract: PLACEHOLDER_CONTRACT };
+};
+
+export const coderAgent = new StateGraph(CoderState)
+  .addNode("generateContract", generateContract)
+  .addEdge(START, "generateContract")
+  .addEdge("generateContract", END)
+  .compile();

src/agents/coder/state.ts

@@ -0,0 +1,7 @@
+import { StateSchema } from "@langchain/langgraph";
+import { z } from "zod";
+
+export const CoderState = new StateSchema({
+  requirements: z.array(z.string()).default([]),
+  contract: z.string().default(""),
+});

src/agents/tester/agent.ts

@@ -0,0 +1,13 @@
+import { END, type GraphNode, START, StateGraph } from "@langchain/langgraph";
+
+import { TesterState } from "./state.ts";
+
+const runTests: GraphNode<typeof TesterState> = async (_state) => {
+  return { results: [] };
+};
+
+export const testerAgent = new StateGraph(TesterState)
+  .addNode("runTests", runTests)
+  .addEdge(START, "runTests")
+  .addEdge("runTests", END)
+  .compile();

src/agents/tester/state.ts

@@ -0,0 +1,8 @@
+import { StateSchema } from "@langchain/langgraph";
+import { z } from "zod";
+
+export const TesterState = new StateSchema({
+  solidityFiles: z.array(z.string()).default([]),
+  vulnerability: z.record(z.string(), z.any()).default({}),
+  results: z.array(z.any()).default([]),
+});

src/index.ts

@@ -1,3 +1,22 @@
 import "dotenv/config";
 
-console.log("TALP 1");
+import { auditorAgent } from "./agents/auditor/agent.ts";
+import { coderAgent } from "./agents/coder/agent.ts";
+import { testerAgent } from "./agents/tester/agent.ts";
+
+const requirements = ["ERC20 token", "pausable", "ownable"];
+
+const coderResult = await coderAgent.invoke({ requirements });
+console.log("======= Coder =======");
+console.log(coderResult.contract);
+
+const auditorResult = await auditorAgent.invoke({ solidityFile: coderResult.contract });
+console.log("\n======= Auditor =======");
+console.log(auditorResult.vulnerabilities);
+
+const testerResult = await testerAgent.invoke({
+  solidityFiles: [coderResult.contract],
+  vulnerability: auditorResult.vulnerabilities[0] ?? {},
+});
+console.log("\n======= Tester =======");
+console.log(testerResult.results);

tsconfig.json

@@ -6,6 +6,7 @@
   "compilerOptions": {
     "rootDir": "./src",
     "outDir": "./dist",
+    "moduleResolution": "nodenext",
     "module": "nodenext",
     "target": "esnext",
     "types": [