Merge remote-tracking branch 'upstream/develop' into develop

* upstream/develop:
  test configuration and tests for client-lens (elizaOS#2534)
  chore(attempt): optimize pnpm cache configuration (elizaOS#2556)
  feat: add a way to create/store/restore agents in the filesystem (elizaOS#2389)
  chore: optimize pnpm cache configuration (elizaOS#2555)
  chore: remove cleanup step from integration tests workflow (elizaOS#2553)
  feat: Add more actions to Abstract Plugin (elizaOS#2531)
  feat: add anthropic image provider for vision (elizaOS#2524)
  feat: improve integrationtests workflow caching (elizaOS#2551)
  feat: Updated READ.me file with pre-requisites to enable telegram bot (elizaOS#2547)
  feat(plugin-devin): implement client-agnostic Devin plugin (elizaOS#2549)
  use generateObject
  handle undefined env variable
  feat:add plugin-lightning (elizaOS#2429)

Author: mgunnin

.env.example

@@ -18,6 +18,9 @@ SUPABASE_ANON_KEY=
 # Comma separated list of remote character urls (optional)
 REMOTE_CHARACTER_URLS=
 
+# Stores characters set by using the direct API in the data/character folder for further load when the app restarts
+USE_CHARACTER_STORAGE=false
+
 # Logging
 DEFAULT_LOG_LEVEL=warn
 LOG_JSON_FORMAT=false            # Print everything in logger as json; false by default
@@ -31,6 +34,9 @@ DISCORD_APPLICATION_ID=
 DISCORD_API_TOKEN=        # Bot token
 DISCORD_VOICE_CHANNEL_ID= # The ID of the voice channel the bot should join (optional)
 
+# Devin Configuration
+DEVIN_API_TOKEN=         # Get your API key from docs.devin.ai/tutorials/api-integration
+
 # Farcaster Neynar Configuration
 FARCASTER_FID=                # The FID associated with the account your are sending casts from
 FARCASTER_NEYNAR_API_KEY=     # Neynar API key: https://neynar.com/
@@ -89,7 +95,7 @@ MEDIUM_OPENAI_MODEL=    # Default: gpt-4o
 LARGE_OPENAI_MODEL=     # Default: gpt-4o
 EMBEDDING_OPENAI_MODEL= # Default: text-embedding-3-small
 IMAGE_OPENAI_MODEL=     # Default: dall-e-3
-USE_OPENAI_EMBEDDING=   # Set to TRUE for OpenAI/1536, leave blank for local
+USE_OPENAI_EMBEDDING=TRUE   # Set to TRUE for OpenAI/1536, leave blank for local
 
 # Community Plugin for OpenAI Configuration
 ENABLE_OPEN_AI_COMMUNITY_PLUGIN=false

.github/workflows/integrationTests.yaml

@@ -22,13 +22,19 @@ jobs:
             - uses: actions/setup-node@v4
               with:
                   node-version: "23.3.0"
-                  cache: "pnpm"
+                  cache: 'pnpm'
+                  cache-dependency-path: '**/pnpm-lock.yaml'
 
-            - name: Clean up
-              run: pnpm clean
+            - name: Configure pnpm
+              run: |
+                  pnpm config set store-dir ~/.pnpm-store
+                  pnpm config set prefer-offline true
+                  pnpm config set node-linker hoisted
+                  pnpm config set shamefully-hoist true
+                  pnpm config list
 
             - name: Install dependencies
-              run: pnpm install -r --no-frozen-lockfile
+              run: pnpm install -r --no-frozen-lockfile --prefer-offline
 
             - name: Build packages
               run: pnpm build

agent/package.json

@@ -102,11 +102,13 @@
         "@elizaos/plugin-hyperliquid": "workspace:*",
         "@elizaos/plugin-akash": "workspace:*",
         "@elizaos/plugin-quai": "workspace:*",
+        "@elizaos/plugin-lightning": "workspace:*",
         "@elizaos/plugin-b2": "workspace:*",
         "@elizaos/plugin-nft-collections": "workspace:*",
         "@elizaos/plugin-pyth-data": "workspace:*",
         "@elizaos/plugin-rabbi-trader": "workspace:*",
         "@elizaos/plugin-openai": "workspace:*",
+        "@elizaos/plugin-devin": "workspace:*",
         "rss-parser": "^3.13.0",
         "readline": "1.3.0",
         "ws": "8.18.0",

agent/src/index.ts

@@ -14,8 +14,9 @@ import { TelegramClientInterface } from "@elizaos/client-telegram";
 import { TwitterClientInterface } from "@elizaos/client-twitter";
 import { agentKitPlugin } from "@elizaos/plugin-agentkit";
 // import { ReclaimAdapter } from "@elizaos/plugin-reclaim";
-import { onchainJson } from "@elizaos/plugin-iq6900";
 import { PrimusAdapter } from "@elizaos/plugin-primus";
+import { lightningPlugin } from "@elizaos/plugin-lightning";
+import { elizaCodeinPlugin, onchainJson } from "@elizaos/plugin-iq6900";
 
 import {
     AgentRuntime,
@@ -109,6 +110,15 @@ import { verifiableLogPlugin } from "@elizaos/plugin-tee-verifiable-log";
 import { thirdwebPlugin } from "@elizaos/plugin-thirdweb";
 import { tonPlugin } from "@elizaos/plugin-ton";
 import { webSearchPlugin } from "@elizaos/plugin-web-search";
+import { injectivePlugin } from "@elizaos/plugin-injective";
+import { giphyPlugin } from "@elizaos/plugin-giphy";
+import { letzAIPlugin } from "@elizaos/plugin-letzai";
+import { thirdwebPlugin } from "@elizaos/plugin-thirdweb";
+import { hyperliquidPlugin } from "@elizaos/plugin-hyperliquid";
+import { echoChambersPlugin } from "@elizaos/plugin-echochambers";
+import { dexScreenerPlugin } from "@elizaos/plugin-dexscreener";
+import { pythDataPlugin } from "@elizaos/plugin-pyth-data";
+import { openaiPlugin } from "@elizaos/plugin-openai";
 
 import { zksyncEraPlugin } from "@elizaos/plugin-zksync-era";
 import Database from "better-sqlite3";
@@ -390,10 +400,32 @@ function commaSeparatedStringToArray(commaSeparated: string): string[] {
     return commaSeparated?.split(",").map((value) => value.trim());
 }
 
+async function readCharactersFromStorage(
+    characterPaths: string[]
+): Promise<string[]> {
+    try {
+        const uploadDir = path.join(process.cwd(), "data", "characters");
+        await fs.promises.mkdir(uploadDir, { recursive: true });
+        const fileNames = await fs.promises.readdir(uploadDir);
+        fileNames.forEach((fileName) => {
+            characterPaths.push(path.join(uploadDir, fileName));
+        });
+    } catch (err) {
+        elizaLogger.error(`Error reading directory: ${err.message}`);
+    }
+
+    return characterPaths;
+}
+
 export async function loadCharacters(
     charactersArg: string
 ): Promise<Character[]> {
-    const characterPaths = commaSeparatedStringToArray(charactersArg);
+    let characterPaths = commaSeparatedStringToArray(charactersArg);
+
+    if (process.env.USE_CHARACTER_STORAGE === "true") {
+        characterPaths = await readCharactersFromStorage(characterPaths);
+    }
+
     const loadedCharacters: Character[] = [];
 
     if (characterPaths?.length > 0) {
@@ -1079,14 +1111,20 @@ export async function createAgent(
             getSecret(character, "RESERVOIR_API_KEY")
                 ? createNFTCollectionsPlugin()
                 : null,
-            // getSecret(character, "PYTH_TESTNET_PROGRAM_KEY") ||
-            // getSecret(character, "PYTH_MAINNET_PROGRAM_KEY")
-            //     ? pythDataPlugin
-            //     : null,
+            getSecret(character, "PYTH_TESTNET_PROGRAM_KEY") ||
+            getSecret(character, "PYTH_MAINNET_PROGRAM_KEY")
+                ? pythDataPlugin
+                : null,
+            getSecret(character, "LND_TLS_CERT") &&
+            getSecret(character, "LND_MACAROON") &&
+            getSecret(character, "LND_SOCKET")
+                ? lightningPlugin
+                : null,
             getSecret(character, "OPENAI_API_KEY") &&
             getSecret(character, "ENABLE_OPEN_AI_COMMUNITY_PLUGIN")
                 ? openaiPlugin
                 : null,
+            getSecret(character, "DEVIN_API_TOKEN") ? devinPlugin : null,
         ].filter(Boolean),
         providers: [],
         actions: [],
@@ -1264,7 +1302,9 @@ const startAgents = async () => {
         characters = await loadCharacterFromOnchain();
     }
 
-    if ((!onchainJson && charactersArg) || hasValidRemoteUrls()) {
+    const notOnchainJson = !onchainJson || onchainJson == "null";
+
+    if ((notOnchainJson && charactersArg) || hasValidRemoteUrls()) {
         characters = await loadCharacters(charactersArg);
     }
 

packages/client-direct/src/api.ts

@@ -1,6 +1,8 @@
 import express from "express";
 import bodyParser from "body-parser";
 import cors from "cors";
+import path from "path";
+import fs from "fs";
 
 import {
     type AgentRuntime,
@@ -80,6 +82,16 @@ export function createApiRouter(
         res.json({ agents: agentsList });
     });
 
+    router.get('/storage', async (req, res) => {
+        try {
+            const uploadDir = path.join(process.cwd(), "data", "characters");
+            const files = await fs.promises.readdir(uploadDir);
+            res.json({ files });
+        } catch (error) {
+            res.status(500).json({ error: error.message });
+        }
+    });
+
     router.get("/agents/:agentId", (req, res) => {
         const { agentId } = validateUUIDParams(req.params, res) ?? {
             agentId: null,
@@ -127,7 +139,7 @@ export function createApiRouter(
         };
         if (!agentId) return;
 
-        const agent: AgentRuntime = agents.get(agentId);
+        let agent: AgentRuntime = agents.get(agentId);
 
         // update character
         if (agent) {
@@ -137,6 +149,9 @@ export function createApiRouter(
             // if it has a different name, the agentId will change
         }
 
+        // stores the json data before it is modified with added data
+        const characterJson = { ...req.body };
+
         // load character from body
         const character = req.body;
         try {
@@ -152,7 +167,7 @@ export function createApiRouter(
 
         // start it up (and register it)
         try {
-            await directClient.startAgent(character);
+            agent = await directClient.startAgent(character);
             elizaLogger.log(`${character.name} started`);
         } catch (e) {
             elizaLogger.error(`Error starting agent: ${e}`);
@@ -162,6 +177,35 @@ export function createApiRouter(
             });
             return;
         }
+
+        if (process.env.USE_CHARACTER_STORAGE === "true") {
+            try {
+                const filename = `${agent.agentId}.json`;
+                const uploadDir = path.join(
+                    process.cwd(),
+                    "data",
+                    "characters"
+                );
+                const filepath = path.join(uploadDir, filename);
+                await fs.promises.mkdir(uploadDir, { recursive: true });
+                await fs.promises.writeFile(
+                    filepath,
+                    JSON.stringify(
+                        { ...characterJson, id: agent.agentId },
+                        null,
+                        2
+                    )
+                );
+                elizaLogger.info(
+                    `Character stored successfully at ${filepath}`
+                );
+            } catch (error) {
+                elizaLogger.error(
+                    `Failed to store character: ${error.message}`
+                );
+            }
+        }
+
         res.json({
             id: character.id,
             character: character,

packages/client-lens/__tests__/client.test.ts

@@ -0,0 +1,124 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { LensClient } from '../src/client';
+import { LensClient as LensClientCore, LimitType, PublicationType } from '@lens-protocol/client';
+
+// Mock dependencies
+vi.mock('@lens-protocol/client', async () => {
+    const actual = await vi.importActual('@lens-protocol/client');
+    return {
+        ...actual,
+        LensClient: vi.fn().mockImplementation(() => ({
+            authentication: {
+                generateChallenge: vi.fn().mockResolvedValue({ id: 'challenge-id', text: 'challenge-text' }),
+                authenticate: vi.fn().mockResolvedValue({ accessToken: 'mock-token', refreshToken: 'mock-refresh' })
+            },
+            profile: {
+                fetch: vi.fn().mockResolvedValue({
+                    id: '0x01',
+                    handle: { localName: 'test.lens' },
+                    metadata: {
+                        displayName: 'Test User',
+                        bio: 'Test bio',
+                        picture: {
+                            uri: 'https://example.com/pic-raw.jpg'
+                        }
+                    }
+                })
+            },
+            publication: {
+                fetchAll: vi.fn().mockResolvedValue({
+                    items: [
+                        {
+                            id: 'pub-1',
+                            metadata: { content: 'Test post' },
+                            stats: { reactions: 10 }
+                        }
+                    ]
+                })
+            }
+        }))
+    };
+});
+
+describe('LensClient', () => {
+    let client: LensClient;
+    const mockRuntime = {
+        name: 'test-runtime',
+        memory: new Map(),
+        getMemory: vi.fn(),
+        setMemory: vi.fn(),
+        clearMemory: vi.fn()
+    };
+    const mockAccount = {
+        address: '0x123' as `0x${string}`,
+        privateKey: '0xabc' as `0x${string}`,
+        signMessage: vi.fn().mockResolvedValue('signed-message'),
+        signTypedData: vi.fn()
+    };
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        client = new LensClient({
+            runtime: mockRuntime,
+            cache: new Map(),
+            account: mockAccount,
+            profileId: '0x01' as `0x${string}`
+        });
+    });
+
+    describe('authenticate', () => {
+        it('should authenticate successfully', async () => {
+            await client.authenticate();
+            expect(client['authenticated']).toBe(true);
+            expect(client['core'].authentication.generateChallenge).toHaveBeenCalledWith({
+                signedBy: mockAccount.address,
+                for: '0x01'
+            });
+            expect(mockAccount.signMessage).toHaveBeenCalledWith({ message: 'challenge-text' });
+        });
+
+        it('should handle authentication errors', async () => {
+            const mockError = new Error('Auth failed');
+            vi.mocked(client['core'].authentication.generateChallenge).mockRejectedValueOnce(mockError);
+            
+            await expect(client.authenticate()).rejects.toThrow('Auth failed');
+            expect(client['authenticated']).toBe(false);
+        });
+    });
+
+    describe('getPublicationsFor', () => {
+        it('should fetch publications successfully', async () => {
+            const publications = await client.getPublicationsFor('0x123');
+            expect(publications).toHaveLength(1);
+            expect(publications[0].id).toBe('pub-1');
+            expect(client['core'].publication.fetchAll).toHaveBeenCalledWith({
+                limit: LimitType.Fifty,
+                where: {
+                    from: ['0x123'],
+                    publicationTypes: [PublicationType.Post]
+                }
+            });
+        });
+
+        it('should handle fetch errors', async () => {
+            vi.mocked(client['core'].publication.fetchAll).mockRejectedValueOnce(new Error('Fetch failed'));
+            await expect(client.getPublicationsFor('0x123')).rejects.toThrow('Fetch failed');
+        });
+    });
+
+    describe('getProfile', () => {
+        it('should fetch profile successfully', async () => {
+            const profile = await client.getProfile('0x123');
+            expect(profile).toBeDefined();
+            expect(profile.id).toBe('0x01');
+            expect(profile.handle).toBe('test.lens');
+            expect(profile.pfp).toBe('https://example.com/pic-raw.jpg');
+            expect(client['core'].profile.fetch).toHaveBeenCalledWith({ forProfileId: '0x123' });
+        });
+
+        it('should handle profile fetch errors', async () => {
+            vi.mocked(client['core'].profile.fetch).mockRejectedValueOnce(new Error('Profile fetch failed'));
+            await expect(client.getProfile('0x123')).rejects.toThrow('Profile fetch failed');
+        });
+    });
+});