feat: add Rabbi Trader plugin integration to AutoClient and agent

Author: mgunnin

agent/package.json

@@ -50,6 +50,7 @@
         "@elizaos/plugin-gitbook": "workspace:*",
         "@elizaos/plugin-story": "workspace:*",
         "@elizaos/plugin-goat": "workspace:*",
+        "@elizaos/plugin-rabbi-trader": "workspace:*",
         "@elizaos/plugin-lensNetwork": "workspace:*",
         "@elizaos/plugin-icp": "workspace:*",
         "@elizaos/plugin-image-generation": "workspace:*",

agent/src/index.ts

@@ -35,7 +35,6 @@ import {
     validateCharacterConfig,
 } from "@elizaos/core";
 // import { zgPlugin } from "@elizaos/plugin-0g";
-
 import { bootstrapPlugin } from "@elizaos/plugin-bootstrap";
 import createGoatPlugin from "@elizaos/plugin-goat";
 // import { intifacePlugin } from "@elizaos/plugin-intiface";
@@ -94,6 +93,7 @@ import { akashPlugin } from "@elizaos/plugin-akash";
 import { OpacityAdapter } from "@elizaos/plugin-opacity";
 import { openWeatherPlugin } from "@elizaos/plugin-open-weather";
 import { quaiPlugin } from "@elizaos/plugin-quai";
+import createRabbiTraderPlugin from "@elizaos/plugin-rabbi-trader";
 import { stargazePlugin } from "@elizaos/plugin-stargaze";
 import Database from "better-sqlite3";
 import fs from "fs";
@@ -669,12 +669,33 @@ export async function createAgent(
     }
 
     let goatPlugin: any | undefined;
+    let rabbiPlugin: any | undefined;
 
     if (getSecret(character, "EVM_PRIVATE_KEY")) {
         goatPlugin = await createGoatPlugin((secret) =>
             getSecret(character, secret)
         );
     }
+    if (getSecret(character, "SOLANA_PRIVATE_KEY")) {
+        const runtime = new AgentRuntime({
+            databaseAdapter: db,
+            token,
+            modelProvider: character.modelProvider,
+            evaluators: [],
+            character,
+            plugins: [],
+            providers: [],
+            actions: [],
+            services: [],
+            managers: [],
+            cacheManager: cache,
+            fetch: logFetch,
+        });
+        rabbiPlugin = await createRabbiTraderPlugin(
+            (secret) => getSecret(character, secret),
+            runtime
+        );
+    }
 
     // Initialize Reclaim adapter if environment variables are present
     // let verifiableInferenceAdapter;
@@ -812,6 +833,7 @@ export async function createAgent(
                 ? webhookPlugin
                 : null,
             goatPlugin,
+            rabbiPlugin,
             getSecret(character, "COINGECKO_API_KEY") ||
             getSecret(character, "COINGECKO_PRO_API_KEY")
                 ? coingeckoPlugin

packages/client-auto/package.json

@@ -20,6 +20,7 @@
     ],
     "dependencies": {
         "@elizaos/core": "workspace:*",
+        "@elizaos/plugin-rabbi-trader": "workspace:*",
         "@types/body-parser": "1.19.5",
         "@types/cors": "2.8.17",
         "@types/express": "5.0.0",

packages/client-auto/src/index.ts

@@ -1,29 +1,100 @@
 import { Client, IAgentRuntime, elizaLogger } from "@elizaos/core";
+import createRabbiTraderPlugin from "@elizaos/plugin-rabbi-trader";
 
 export class AutoClient {
-    interval: NodeJS.Timeout;
-    runtime: IAgentRuntime;
+    private interval: NodeJS.Timeout | null = null;
+    private runtime: IAgentRuntime;
+    private plugin: any;
+    static readonly CLIENT_NAME = "auto";
 
     constructor(runtime: IAgentRuntime) {
+        elizaLogger.log("AutoClient constructor called");
         this.runtime = runtime;
+        this.initialize();
+    }
+
+    private async initialize() {
+        try {
+            elizaLogger.log("AutoClient initialization started");
+            await this.initializePlugin();
+            elizaLogger.log("AutoClient initialization completed");
+        } catch (error) {
+            elizaLogger.error("AutoClient initialization failed:", error);
+            throw error;
+        }
+    }
+
+    private async initializePlugin() {
+        try {
+            elizaLogger.log(
+                "Initializing Rabbi Trader plugin in AutoClient..."
+            );
+
+            this.plugin = await createRabbiTraderPlugin(
+                (key: string) => this.runtime.getSetting(key),
+                this.runtime
+            );
+
+            elizaLogger.log("Plugin created, initializing...");
+            await this.plugin.initialize(this.runtime);
+
+            elizaLogger.log("Plugin initialized, starting...");
+            await this.plugin.start();
+
+            if (this.plugin.onStart) {
+                elizaLogger.log("Triggering plugin onStart...");
+                await this.plugin.onStart();
+            }
+
+            elizaLogger.log(
+                "Rabbi Trader plugin fully initialized and started in AutoClient"
+            );
+        } catch (error) {
+            elizaLogger.error(
+                "Failed to initialize Rabbi Trader plugin in AutoClient:",
+                {
+                    error,
+                    phase: "initialization",
+                    pluginState: this.plugin ? "created" : "null",
+                }
+            );
+            throw error;
+        }
+    }
+
+    public async stop() {
+        elizaLogger.log("Stopping AutoClient...");
+        try {
+            if (this.interval) {
+                clearInterval(this.interval);
+                this.interval = null;
+            }
+
+            if (this.plugin?.cleanup) {
+                await this.plugin.cleanup();
+            }
 
-        // start a loop that runs every x seconds
-        this.interval = setInterval(
-            async () => {
-                elizaLogger.log("running auto client...");
-            },
-            60 * 60 * 1000
-        ); // 1 hour in milliseconds
+            elizaLogger.log("AutoClient stopped successfully");
+        } catch (error) {
+            elizaLogger.error("Error stopping AutoClient:", error);
+            throw error;
+        }
     }
 }
 
 export const AutoClientInterface: Client = {
     start: async (runtime: IAgentRuntime) => {
+        elizaLogger.log("Starting AutoClient interface...");
         const client = new AutoClient(runtime);
         return client;
     },
-    stop: async (_runtime: IAgentRuntime) => {
-        console.warn("Direct client does not support stopping yet");
+    stop: async (runtime: IAgentRuntime) => {
+        elizaLogger.log("Stopping AutoClient interface...");
+        const clients = (runtime as any).clients || {};
+        const client = clients["auto"] as AutoClient;
+        if (client) {
+            await client.stop();
+        }
     },
 };