Merge remote-tracking branch 'origin/develop' into eternalai-agent

# Conflicts:
#	.env.example

Author: eternal-ai-org

.env.example

@@ -61,33 +61,21 @@ cp .env.example .env
 pnpm i && pnpm build && pnpm start
 ```
 
-Once the agent is running, you should see the message to run "pnpm start:client" at the end.
-Open another terminal and move to same directory and then run below command and follow the URL to chat to your agent.
-
-```bash
-pnpm start:client
-```
-
-Then read the [Documentation](https://elizaos.github.io/eliza/) to learn how to customize your Eliza.
-
 ### Manually Start Eliza (Only recommended if you know what you are doing)
 
+#### Checkout the latest release
+
 ```bash
 # Clone the repository
 git clone https://github.com/elizaos/eliza.git
 
-# Checkout the latest release
 # This project iterates fast, so we recommend checking out the latest release
 git checkout $(git describe --tags --abbrev=0)
 # If the above doesn't checkout the latest release, this should work:
 # git checkout $(git describe --tags `git rev-list --tags --max-count=1`)
 ```
 
-### Start Eliza with Gitpod
-
-[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/elizaos/eliza/tree/main)
-
-### Edit the .env file
+#### Edit the .env file
 
 Copy .env.example to .env and fill in the appropriate values.
 
@@ -97,6 +85,32 @@ cp .env.example .env
 
 Note: .env is optional. If you're planning to run multiple distinct agents, you can pass secrets through the character JSON
 
+
+#### Start Eliza
+
+```bash
+pnpm i
+pnpm build
+pnpm start
+
+# The project iterates fast, sometimes you need to clean the project if you are coming back to the project
+pnpm clean
+```
+
+### Interact via Browser
+
+```
+Once the agent is running, you should see the message to run "pnpm start:client" at the end.
+Open another terminal and move to same directory and then run below command and follow the URL to chat to your agent.
+
+```bash
+pnpm start:client
+```
+
+Then read the [Documentation](https://elizaos.github.io/eliza/) to learn how to customize your Eliza.
+
+----
+
 ### Automatically Start Eliza
 
 The start script provides an automated way to set up and run Eliza:
@@ -109,7 +123,9 @@ For detailed instructions on using the start script, including character managem
 
 > **Note**: The start script handles all dependencies, environment setup, and character management automatically.
 
-### Edit the character file
+----
+
+### Modify Character
 
 1. Open `packages/core/src/defaultCharacter.ts` to modify the default character. Uncomment and edit.
 
@@ -119,16 +135,7 @@ For detailed instructions on using the start script, including character managem
 3. Connect with X (Twitter)
     - change `"clients": []` to `"clients": ["twitter"]` in the character file to connect with X
 
-### Manually Start Eliza
-
-```bash
-pnpm i
-pnpm build
-pnpm start
-
-# The project iterates fast, sometimes you need to clean the project if you are coming back to the project
-pnpm clean
-```
+---
 
 #### Additional Requirements
 
@@ -137,6 +144,14 @@ You may need to install Sharp. If you see an error when starting up, try install
 ```
 pnpm install --include=optional sharp
 ```
+---
+
+
+### Start Eliza with Gitpod
+
+[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/elizaos/eliza/tree/main)
+
+---
 
 ### Community & contact
 

README.md

@@ -184,12 +184,17 @@ function mergeCharacters(base: Character, child: Character): Character {
     };
     return mergeObjects(base, child);
 }
-async function loadCharacter(filePath: string): Promise<Character> {
-    const content = tryLoadFile(filePath);
-    if (!content) {
-        throw new Error(`Character file not found: ${filePath}`);
-    }
-    let character = JSON.parse(content);
+
+async function loadCharacterFromUrl(url: string): Promise<Character> {
+    const response = await fetch(url);
+    const character = await response.json();
+    return jsonToCharacter(url, character);
+}
+
+async function jsonToCharacter(
+    filePath: string,
+    character: any
+): Promise<Character> {
     validateCharacterConfig(character);
 
     // .id isn't really valid
@@ -227,6 +232,15 @@ async function loadCharacter(filePath: string): Promise<Character> {
     return character;
 }
 
+async function loadCharacter(filePath: string): Promise<Character> {
+    const content = tryLoadFile(filePath);
+    if (!content) {
+        throw new Error(`Character file not found: ${filePath}`);
+    }
+    let character = JSON.parse(content);
+    return jsonToCharacter(filePath, character);
+}
+
 export async function loadCharacters(
     charactersArg: string
 ): Promise<Character[]> {
@@ -305,6 +319,16 @@ export async function loadCharacters(
     }
 
     if (loadedCharacters.length === 0) {
+        if (
+            process.env.REMOTE_CHARACTER_URL != "" &&
+            process.env.REMOTE_CHARACTER_URL.startsWith("http")
+        ) {
+            const character = await loadCharacterFromUrl(
+                process.env.REMOTE_CHARACTER_URL
+            );
+            loadedCharacters.push(character);
+        }
+
         elizaLogger.info("No characters found, using default character");
         loadedCharacters.push(defaultCharacter);
     }
@@ -1116,14 +1140,17 @@ startAgents().catch((error) => {
 });
 
 // Prevent unhandled exceptions from crashing the process if desired
-if (process.env.PREVENT_UNHANDLED_EXIT && parseBooleanFromText(process.env.PREVENT_UNHANDLED_EXIT)) {
+if (
+    process.env.PREVENT_UNHANDLED_EXIT &&
+    parseBooleanFromText(process.env.PREVENT_UNHANDLED_EXIT)
+) {
     // Handle uncaught exceptions to prevent the process from crashing
-    process.on('uncaughtException', function(err) {
+    process.on("uncaughtException", function (err) {
         console.error("uncaughtException", err);
     });
 
     // Handle unhandled rejections to prevent the process from crashing
-    process.on('unhandledRejection', function(err) {
+    process.on("unhandledRejection", function (err) {
         console.error("unhandledRejection", err);
     });
 }

agent/src/index.ts

@@ -333,6 +333,33 @@ export class PGLiteDatabaseAdapter
         }, "getMemoryById");
     }
 
+    async getMemoriesByIds(
+        memoryIds: UUID[],
+        tableName?: string
+    ): Promise<Memory[]> {
+        return this.withDatabase(async () => {
+            if (memoryIds.length === 0) return [];
+            const placeholders = memoryIds.map((_, i) => `$${i + 1}`).join(",");
+            let sql = `SELECT * FROM memories WHERE id IN (${placeholders})`;
+            const queryParams: any[] = [...memoryIds];
+
+            if (tableName) {
+                sql += ` AND type = $${memoryIds.length + 1}`;
+                queryParams.push(tableName);
+            }
+
+            const { rows } = await this.query<Memory>(sql, queryParams);
+
+            return rows.map((row) => ({
+                ...row,
+                content:
+                    typeof row.content === "string"
+                        ? JSON.parse(row.content)
+                        : row.content,
+            }));
+        }, "getMemoriesByIds");
+    }
+
     async createMemory(memory: Memory, tableName: string): Promise<void> {
         return this.withDatabase(async () => {
             elizaLogger.debug("PostgresAdapter createMemory:", {

packages/adapter-pglite/src/index.ts

@@ -512,6 +512,33 @@ export class PostgresDatabaseAdapter
         }, "getMemoryById");
     }
 
+    async getMemoriesByIds(
+        memoryIds: UUID[],
+        tableName?: string
+    ): Promise<Memory[]> {
+        return this.withDatabase(async () => {
+            if (memoryIds.length === 0) return [];
+            const placeholders = memoryIds.map((_, i) => `$${i + 1}`).join(",");
+            let sql = `SELECT * FROM memories WHERE id IN (${placeholders})`;
+            const queryParams: any[] = [...memoryIds];
+
+            if (tableName) {
+                sql += ` AND type = $${memoryIds.length + 1}`;
+                queryParams.push(tableName);
+            }
+
+            const { rows } = await this.pool.query(sql, queryParams);
+
+            return rows.map((row) => ({
+                ...row,
+                content:
+                    typeof row.content === "string"
+                        ? JSON.parse(row.content)
+                        : row.content,
+            }));
+        }, "getMemoriesByIds");
+    }
+
     async createMemory(memory: Memory, tableName: string): Promise<void> {
         return this.withDatabase(async () => {
             elizaLogger.debug("PostgresAdapter createMemory:", {

packages/adapter-postgres/src/index.ts

@@ -204,6 +204,33 @@ export class SqliteDatabaseAdapter
         return null;
     }
 
+    async getMemoriesByIds(
+        memoryIds: UUID[],
+        tableName?: string
+    ): Promise<Memory[]> {
+        if (memoryIds.length === 0) return [];
+        const queryParams: any[] = [];
+        const placeholders = memoryIds.map(() => "?").join(",");
+        let sql = `SELECT * FROM memories WHERE id IN (${placeholders})`;
+        queryParams.push(...memoryIds);
+
+        if (tableName) {
+            sql += ` AND type = ?`;
+            queryParams.push(tableName);
+        }
+
+        const memories = this.db.prepare(sql).all(...queryParams) as Memory[];
+
+        return memories.map((memory) => ({
+            ...memory,
+            createdAt:
+                typeof memory.createdAt === "string"
+                    ? Date.parse(memory.createdAt as string)
+                    : memory.createdAt,
+            content: JSON.parse(memory.content as unknown as string),
+        }));
+    }
+
     async createMemory(memory: Memory, tableName: string): Promise<void> {
         // Delete any existing memory with the same ID first
         // const deleteSql = `DELETE FROM memories WHERE id = ? AND type = ?`;

packages/adapter-sqlite/src/index.ts

@@ -237,6 +237,35 @@ export class SqlJsDatabaseAdapter
         return memory || null;
     }
 
+    async getMemoriesByIds(
+        memoryIds: UUID[],
+        tableName?: string
+    ): Promise<Memory[]> {
+        if (memoryIds.length === 0) return [];
+        const placeholders = memoryIds.map(() => "?").join(",");
+        let sql = `SELECT * FROM memories WHERE id IN (${placeholders})`;
+        const queryParams: any[] = [...memoryIds];
+
+        if (tableName) {
+            sql += ` AND type = ?`;
+            queryParams.push(tableName);
+        }
+
+        const stmt = this.db.prepare(sql);
+        stmt.bind(queryParams);
+
+        const memories: Memory[] = [];
+        while (stmt.step()) {
+            const memory = stmt.getAsObject() as unknown as Memory;
+            memories.push({
+                ...memory,
+                content: JSON.parse(memory.content as unknown as string),
+            });
+        }
+        stmt.free();
+        return memories;
+    }
+
     async createMemory(memory: Memory, tableName: string): Promise<void> {
         let isUnique = true;
         if (memory.embedding) {

packages/adapter-sqljs/src/index.ts

@@ -370,6 +370,31 @@ export class SupabaseDatabaseAdapter extends DatabaseAdapter {
         return data as Memory;
     }
 
+    async getMemoriesByIds(
+        memoryIds: UUID[],
+        tableName?: string
+    ): Promise<Memory[]> {
+        if (memoryIds.length === 0) return [];
+
+        let query = this.supabase
+            .from("memories")
+            .select("*")
+            .in("id", memoryIds);
+
+        if (tableName) {
+            query = query.eq("type", tableName);
+        }
+
+        const { data, error } = await query;
+
+        if (error) {
+            console.error("Error retrieving memories by IDs:", error);
+            return [];
+        }
+
+        return data as Memory[];
+    }
+
     async createMemory(
         memory: Memory,
         tableName: string,

packages/adapter-supabase/src/index.ts

@@ -15,6 +15,18 @@ class MockDatabaseAdapter extends DatabaseAdapter {
     getMemoryById(_id: UUID): Promise<Memory | null> {
         throw new Error("Method not implemented.");
     }
+    async getMemoriesByIds(
+        memoryIds: UUID[],
+        _tableName?: string
+    ): Promise<Memory[]> {
+        return memoryIds.map((id) => ({
+            id: id,
+            content: { text: "Test Memory" },
+            roomId: "room-id" as UUID,
+            userId: "user-id" as UUID,
+            agentId: "agent-id" as UUID,
+        })) as Memory[];
+    }
     log(_params: {
         body: { [key: string]: unknown };
         userId: UUID;