@autonomaai/agent-core 1.0.2

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@autonomaai/agent-core",
+  "version": "1.0.2",
+  "description": "Standardized agent core for autonoma AI agents with LangGraph + AgentKit integration",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "jest",
+    "lint": "eslint src/**/*.ts"
+  },
+  "keywords": [
+    "langchain",
+    "langgraph",
+    "agentkit",
+    "ai-agent",
+    "trading",
+    "crypto",
+    "agent-core"
+  ],
+  "author": "autonoma Team",
+  "license": "MIT",
+  "dependencies": {
+    "@autonomaai/mcp-client": "^1.0.1",
+    "@coinbase/agentkit": "^0.3.0",
+    "@coinbase/agentkit-langchain": "^0.3.0",
+    "@langchain/core": "^0.3.29",
+    "@langchain/langgraph": "^0.2.39",
+    "@langchain/openai": "^0.6.1"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.7.0",
+    "@typescript-eslint/parser": "^6.7.0",
+    "eslint": "^8.50.0",
+    "jest": "^29.7.0",
+    "typescript": "^5.2.0"
+  },
+  "peerDependencies": {
+    "typescript": ">=4.0.0"
+  },
+  "files": [
+    "dist/**/*",
+    "src/**/*",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/autonoma/autonoma"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/base-agent.ts

@@ -0,0 +1,263 @@
+/**
+ * Base Agent Class
+ * 
+ * Reusable base class for all AI agents in the platform.
+ * Provides common functionality: chat, sessions, status, lifecycle management.
+ * 
+ * Each specific agent (ExpenseAnalyzer, MarketMaker, etc.) extends this class
+ * and adds domain-specific methods and tools.
+ */
+
+import { StandardAgent, AgentMessage, AgentResponse, createTradingAgent } from './index.js';
+
+/**
+ * Logger interface abstraction
+ * Decouples from specific logging libraries
+ */
+export interface ILogger {
+  info(message: string | object, ...args: any[]): void;
+  error(message: string | object, ...args: any[]): void;
+  warn(message: string | object, ...args: any[]): void;
+  debug(message: string | object, ...args: any[]): void;
+}
+
+/**
+ * Chat message interface
+ */
+export interface ChatMessage {
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+  timestamp: string;
+}
+
+/**
+ * Chat session interface
+ */
+export interface ChatSession {
+  sessionId: string;
+  messages: ChatMessage[];
+  metadata?: Record<string, any>;
+}
+
+/**
+ * Base agent configuration
+ */
+export interface BaseAgentConfig {
+  name: string;
+  description: string;
+  systemPrompt: string;
+  logger: ILogger;
+  llm: {
+    model: string;
+    temperature: number;
+    maxTokens: number;
+    openAIApiKey: string;
+  };
+  memory: {
+    enabled: boolean;
+    persistentThreadId: boolean;
+    maxMessages: number;
+  };
+  capabilities?: string[];
+  enableRAG?: boolean;
+}
+
+/**
+ * Base Agent Class
+ * 
+ * All agents extend this class and inherit common functionality.
+ * Specific agents can override methods or add domain-specific ones.
+ */
+export abstract class BaseAgent {
+  protected agent: StandardAgent;
+  protected logger: ILogger;
+  protected sessions: Map<string, ChatSession>;
+  protected startTime: number;
+  protected config: BaseAgentConfig;
+
+  constructor(config: BaseAgentConfig) {
+    this.config = config;
+    this.logger = config.logger;
+    this.sessions = new Map();
+    this.startTime = Date.now();
+
+    // Initialize StandardAgent from agent-core
+    this.agent = createTradingAgent({
+      name: config.name,
+      description: config.description,
+      
+      llm: {
+        model: config.llm.model,
+        temperature: config.llm.temperature,
+        maxTokens: config.llm.maxTokens,
+        openAIApiKey: config.llm.openAIApiKey
+      },
+      
+      memory: {
+        enabled: config.memory.enabled,
+        persistentThreadId: config.memory.persistentThreadId,
+        maxMessages: config.memory.maxMessages
+      },
+      
+      prompt: {
+        systemMessage: config.systemPrompt,
+        capabilities: (config.capabilities || []) as any, // Allow any string capabilities
+        enableConversationMemory: config.memory.enabled
+      },
+      
+      services: {
+        messageService: true,
+        ragService: config.enableRAG || false,
+        loggingEnabled: true
+      }
+    });
+
+    this.logger.info(`✅ ${config.name} initialized`);
+  }
+
+  /**
+   * Start the agent
+   */
+  async start(): Promise<void> {
+    try {
+      await this.agent.start();
+      this.logger.info(`🚀 ${this.config.name} started successfully`);
+    } catch (error) {
+      this.logger.error(`❌ Failed to start ${this.config.name}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Process a user message and return AI response
+   */
+  async chat(
+    userMessage: string,
+    sessionId: string,
+    contextMetadata?: Record<string, any>
+  ): Promise<AgentResponse> {
+    try {
+      const startTime = Date.now();
+      this.logger.info(
+        { sessionId, contextMetadata },
+        `💬 Processing chat message: ${userMessage.substring(0, 100)}...`
+      );
+
+      // Get or create session
+      let session = this.sessions.get(sessionId);
+      if (!session) {
+        session = {
+          sessionId,
+          messages: [],
+          metadata: { 
+            createdAt: new Date().toISOString(),
+            ...contextMetadata
+          }
+        };
+        this.sessions.set(sessionId, session);
+      }
+
+      // Add user message to session history
+      session.messages.push({
+        role: 'user',
+        content: userMessage,
+        timestamp: new Date().toISOString()
+      });
+
+      // Process through LangGraph agent
+      const agentMessage: AgentMessage = {
+        content: userMessage,
+        timestamp: new Date().toISOString(),
+        role: 'user',
+        metadata: {
+          sessionId,
+          messageCount: session.messages.length,
+          ...contextMetadata
+        }
+      };
+
+      const response = await this.agent.process(agentMessage);
+
+      // Add assistant response to session history
+      session.messages.push({
+        role: 'assistant',
+        content: response.content,
+        timestamp: new Date().toISOString()
+      });
+
+      // Trim history if too long
+      if (session.messages.length > this.config.memory.maxMessages) {
+        session.messages = session.messages.slice(-this.config.memory.maxMessages);
+      }
+
+      const processingTime = Date.now() - startTime;
+      this.logger.info(
+        { sessionId, processingTime, tokensUsed: response.metrics?.tokensUsed },
+        `✅ Chat response generated in ${processingTime}ms`
+      );
+
+      return response;
+
+    } catch (error) {
+      this.logger.error({ sessionId, error }, '❌ Error processing chat message');
+      throw error;
+    }
+  }
+
+  /**
+   * Get session history
+   */
+  getSession(sessionId: string): ChatSession | undefined {
+    return this.sessions.get(sessionId);
+  }
+
+  /**
+   * Clear session history
+   */
+  clearSession(sessionId: string): void {
+    this.sessions.delete(sessionId);
+    this.logger.info({ sessionId }, 'Session cleared');
+  }
+
+  /**
+   * Get all active sessions
+   */
+  getActiveSessions(): string[] {
+    return Array.from(this.sessions.keys());
+  }
+
+  /**
+   * Get agent status
+   */
+  getStatus() {
+    return {
+      name: this.config.name,
+      status: 'running',
+      uptime: Date.now() - this.startTime,
+      activeSessions: this.sessions.size,
+      model: this.config.llm.model,
+      capabilities: this.config.capabilities || []
+    };
+  }
+
+  /**
+   * Stop the agent
+   */
+  async stop(): Promise<void> {
+    try {
+      await this.agent.stop();
+      this.logger.info(`🛑 ${this.config.name} stopped`);
+    } catch (error) {
+      this.logger.error('Error stopping agent:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Get underlying StandardAgent (for advanced use)
+   */
+  protected getUnderlyingAgent(): StandardAgent {
+    return this.agent;
+  }
+}
+