refactor: move env management (#11)

Author: francis2tm

apps/web/.env.example

@@ -0,0 +1,5 @@
+# Server configuration
+PORT=2512
+
+# Atoma SDK configuration
+ATOMASDK_BEARER_AUTH=your_bearer_auth_token_here 

apps/web/src/config.ts

@@ -6,4 +6,5 @@ dotenv.config();
 // Application configuration
 export const config = {
   port: process.env.PORT || 2512, // Default port if not specified in environment
+  atomaSdkBearerAuth: process.env.ATOMASDK_BEARER_AUTH, // Bearer auth token for Atoma SDK
 }; 

packages/sui-agent/.env.example

@@ -20,14 +20,13 @@
     "aftermath-ts-sdk": "^1.2.49",
     "atoma-sdk": "github:atoma-network/atoma-sdk-typescript",
     "axios": "^1.7.9",
-    "dotenv": "^16.4.7",
     "typescript": "^5.7.3"
   },
   "devDependencies": {
     "@types/node": "^20.11.19",
     "@typescript-eslint/eslint-plugin": "^5.0.0",
     "@typescript-eslint/parser": "^5.0.0",
-    "prettier": "^3.4.2",
-    "eslint": "^8.57.0"
+    "eslint": "^8.57.0",
+    "prettier": "^3.4.2"
   }
 }

packages/sui-agent/package.json

@@ -2,39 +2,37 @@ import { IntentAgentResponse } from '../@types/interface';
 import Tools from '../tools/aftermath';
 import { registerAllTools } from './ToolRegistry';
 import Utils from '../utils';
-
-/**
- * Tools instance for handling various tool-related operations
- * Used across the agent system for processing and executing tasks
- */
-const tools = new Tools();
-
-/**
- * Utils instance that provides utility functions
- * Initialized with tools instance for coordinated operations
- */
-const utils = new Utils(tools);
+import intent_agent_prompt from '../prompts/intent_agent_prompt';
+import final_answer_agent_prompt from '../prompts/final_answer_agent';
 
 /**
  * Main agent class that handles intent processing and decision making
  * Coordinates between different agent types to process user queries
  *
  * @example
- * const agent = new Agents();
+ * const agent = new Agents("your-bearer-auth-token");
  * const response = await agent.SuperVisorAgent("What is the current price of the Sui token?");
  * console.log(response);
  */
 class Agents {
+  private tools: Tools;
+  private utils: Utils;
+
+  constructor(bearerAuth: string) {
+    this.tools = new Tools(bearerAuth, intent_agent_prompt);
+    this.utils = new Utils(bearerAuth, final_answer_agent_prompt);
+  }
+
   /**
    * Processes initial user intent and selects appropriate tools
    * @param prompt - User's input query
    * @returns IntentAgentResponse containing tool selection and processing details
    */
   async IntentAgent(prompt: string) {
     // Register all available tools before processing
-    registerAllTools(tools);
+    registerAllTools(this.tools);
     const IntentResponse: IntentAgentResponse =
-      (await tools.selectAppropriateTool(prompt)) as IntentAgentResponse;
+      (await this.tools.selectAppropriateTool(prompt)) as IntentAgentResponse;
     return IntentResponse;
   }
 
@@ -45,10 +43,7 @@ class Agents {
    * @returns Processed response after decision making
    */
   async DecisionMakingAgent(intentResponse: any, query: string) {
-    return await utils.makeDecision(
-      intentResponse as IntentAgentResponse,
-      query,
-    );
+    return await this.utils.processQuery(query);
   }
 
   /**

packages/sui-agent/src/agents/SuiAgent.ts

@@ -1,27 +1,30 @@
-import dotenv from 'dotenv';
 import { AtomaSDK } from 'atoma-sdk';
 
-dotenv.config();
-
 const ATOMA_CHAT_COMPLETIONS_MODEL = 'meta-llama/Llama-3.3-70B-Instruct';
 
-// Initialize Atoma SDK with authentication
-const atomaSDK = new AtomaSDK({
-  bearerAuth: process.env.ATOMASDK_BEARER_AUTH,
-});
+/**
+ * Initialize Atoma SDK with authentication
+ * @param bearerAuth - Bearer auth token for Atoma SDK
+ * @returns Initialized Atoma SDK instance
+ */
+export function initializeAtomaSDK(bearerAuth: string): AtomaSDK {
+  return new AtomaSDK({ bearerAuth });
+}
 
 /**
  * Helper function to create chat completions using Atoma SDK
+ * @param sdk - Initialized Atoma SDK instance
  * @param messages - Array of message objects with content and role
  * @param model - Optional model identifier (defaults to Llama-3.3-70B-Instruct)
  * @returns Chat completion response
  */
 async function atomaChat(
+  sdk: AtomaSDK,
   messages: { content: string; role: string }[],
   model?: string,
 ) {
   try {
-    return await atomaSDK.chat.create({
+    return await sdk.chat.create({
       messages,
       model: model || ATOMA_CHAT_COMPLETIONS_MODEL,
       maxTokens: 128,
@@ -53,10 +56,14 @@ async function atomaChat(
   }
 }
 
-// Health check function that returns service status
-async function isAtomaHealthy(): Promise<boolean> {
+/**
+ * Health check function that returns service status
+ * @param sdk - Initialized Atoma SDK instance
+ * @returns Boolean indicating if service is healthy
+ */
+async function isAtomaHealthy(sdk: AtomaSDK): Promise<boolean> {
   try {
-    await atomaSDK.health.health();
+    await sdk.health.health();
     return true;
   } catch (error) {
     console.error('Atoma health check failed:', error);
@@ -65,4 +72,3 @@ async function isAtomaHealthy(): Promise<boolean> {
 }
 
 export { atomaChat, isAtomaHealthy };
-export default atomaSDK;

packages/sui-agent/src/config/atoma.ts

@@ -1,7 +1,6 @@
-import intent_agent_prompt from '../../prompts/intent_agent_prompt';
-
-import { Tool, ToolParameter, toolResponse } from '../../@types/interface';
+import { Tool, toolResponse } from '../../@types/interface';
 import { atomaChat } from '../../config/atoma';
+import { AtomaSDK } from 'atoma-sdk';
 
 /**
  * Main tools management class
@@ -10,54 +9,53 @@ import { atomaChat } from '../../config/atoma';
 class Tools {
   private tools: Tool[] = [];
   private prompt: string;
+  private sdk: AtomaSDK;
 
-  constructor() {
-    this.prompt = intent_agent_prompt;
+  constructor(bearerAuth: string, prompt: string) {
+    this.prompt = prompt;
+    this.sdk = new AtomaSDK({ bearerAuth });
   }
 
   /**
-   * Register a new tool with the system
-   * @param name - Name of the tool
-   * @param description - Description of what the tool does
-   * @param parameters - Parameters the tool accepts
-   * @param process - Function to execute the tool
+   * Register a new tool
+   * @param name - Tool name
+   * @param description - Tool description
+   * @param parameters - Tool parameters
+   * @param process - Tool process function
    */
   registerTool(
     name: string,
     description: string,
-    parameters: ToolParameter[],
-    process: (...args: any[]) => Promise<string> | string,
-  ): void {
-    const tool: Tool = {
-      name,
-      description,
-      parameters,
-      process,
-    };
-    this.tools.push(tool);
+    parameters: { name: string; type: string; description: string; required: boolean }[],
+    process: (...args: any[]) => any
+  ) {
+    this.tools.push({ name, description, parameters, process });
   }
 
   /**
    * Select appropriate tool based on user query
-   * @param query - User's input query
-   * @returns Selected tool response or null if no tool matches
+   * @param query - User query
+   * @returns Selected tool response or null if no tool found
    */
   async selectAppropriateTool(query: string): Promise<toolResponse | null> {
     const finalPrompt = this.prompt.replace(
       '${toolsList}',
       JSON.stringify(this.getAllTools()),
     );
 
-    const ai: any = await atomaChat([
-      {
-        content: finalPrompt,
-        role: 'system',
-      },
-      {
-        content: query || '',
-        role: 'user',
-      },
-    ]);
+    const ai: any = await atomaChat(
+      this.sdk,
+      [
+        {
+          content: finalPrompt,
+          role: 'system',
+        },
+        {
+          content: query || '',
+          role: 'user',
+        },
+      ]
+    );
     const res = ai.choices[0].message.content;
 
     const applicableTools: toolResponse[] = JSON.parse(res);
@@ -74,6 +72,7 @@ class Tools {
     return this.tools;
   }
 }
+
 export default Tools;
 
 //   tools.registerTool("Tool 1", "Description of Tool 1", () => {

packages/sui-agent/src/tools/aftermath/index.ts

@@ -1,66 +1,73 @@
-import final_answer_agent_prompt from '../prompts/final_answer_agent';
+import { randomUUID } from 'crypto';
+import { AtomaSDK } from 'atoma-sdk';
 import { atomaChat } from '../config/atoma';
 import Tools from '../tools/aftermath';
 import { IntentAgentResponse } from '../@types/interface';
-import { randomUUID } from 'crypto';
 
 /**
  * Utility class for processing agent responses and making decisions
  * Handles the execution of tools and formatting of final responses
  */
 class Utils {
   private tools: Tools;
+  private sdk: AtomaSDK;
+  private prompt: string;
 
-  constructor(tools: Tools) {
-    this.tools = tools;
+  constructor(bearerAuth: string, prompt: string) {
+    this.tools = new Tools(bearerAuth, prompt);
+    this.sdk = new AtomaSDK({ bearerAuth });
+    this.prompt = prompt;
   }
 
   /**
-   * Makes decisions based on intent agent response and executes appropriate actions
-   * @param intent_agent_response - Response from the intent agent
-   * @param query - Original user query
-   * @param tools - Optional tools configuration
-   * @returns Processed and formatted response
+   * Process user query and execute appropriate tool
+   * @param query - User query
+   * @returns Processed response
    */
-  async makeDecision(
-    intent_agent_response: IntentAgentResponse,
-    query: string,
-    tools?: any,
-  ) {
-    if (intent_agent_response.success && intent_agent_response.selected_tool) {
-      return await this.executeTools(
-        intent_agent_response.selected_tool,
-        intent_agent_response.tool_arguments,
-      );
-    } else {
-      return await this.finalAnswer(
-        intent_agent_response.response,
+  async processQuery(query: string): Promise<any> {
+    try {
+      const selectedTool = await this.tools.selectAppropriateTool(query);
+      if (!selectedTool) {
+        return this.finalAnswer('No tool found for the query', query);
+      }
+
+      return this.executeTools(selectedTool.selected_tool || '', selectedTool.tool_arguments || []);
+    } catch (error: unknown) {
+      console.error('Error processing query:', error);
+      return handleError(error, {
+        reasoning: 'The system encountered an issue while processing your query',
         query,
-        tools,
-      );
+      });
     }
   }
 
   /**
-   * Formats and processes the final answer using the AI model
-   * @param response - Raw response to be formatted
-   * @param query - Original user query
-   * @param tools - Optional tools used in processing
-   * @returns Formatted final response
+   * Format final answer
+   * @param response - Raw response
+   * @param query - Original query
+   * @param tools - Tools used
+   * @returns Formatted response
    * @private
    */
-  private async finalAnswer(response: any, query: string, tools?: any) {
-    const finalPrompt = final_answer_agent_prompt
+  private async finalAnswer(
+    response: string,
+    query: string,
+    tools?: string,
+  ): Promise<any> {
+    const finalPrompt = this.prompt
       .replace('${query}', query)
       .replace('${response}', response)
       .replace('tools', `${tools || null}`);
 
-    const finalAns: any = await atomaChat([
-      {
-        content: finalPrompt,
-        role: 'assistant',
-      },
-    ]);
+    const finalAns: any = await atomaChat(
+      this.sdk,
+      [
+        {
+          content: finalPrompt,
+          role: 'assistant',
+        },
+      ]
+    );
     const res = finalAns.choices[0].message.content;
     console.log(finalPrompt);
     return JSON.parse(res);