Merge branch 'ai16z:main' into main

Author: ai16z-demirix

.github/workflows/require-develop.yml

@@ -0,0 +1,18 @@
+name: Check pull request source branch
+on:
+    pull_request_target:
+        types:
+            - opened
+            - reopened
+            - synchronize
+            - edited
+jobs:
+    check-branches:
+        runs-on: ubuntu-latest
+        steps:
+            - name: Check branches
+              run: |
+                  if [ ${{ github.head_ref }} != "develop" ] && [ ${{ github.base_ref }} == "main" ]; then
+                    echo "Merge requests to main branch are only allowed from dev branch."
+                    exit 1
+                  fi

agent/src/index.ts

@@ -459,14 +459,14 @@ export async function createAgent(
     });
 }
 
-function intializeFsCache(baseDir: string, character: Character) {
+function initializeFsCache(baseDir: string, character: Character) {
     const cacheDir = path.resolve(baseDir, character.id, "cache");
 
     const cache = new CacheManager(new FsCacheAdapter(cacheDir));
     return cache;
 }
 
-function intializeDbCache(character: Character, db: IDatabaseCacheAdapter) {
+function initializeDbCache(character: Character, db: IDatabaseCacheAdapter) {
     const cache = new CacheManager(new DbCacheAdapter(db, character.id));
     return cache;
 }
@@ -489,7 +489,7 @@ async function startAgent(character: Character, directClient) {
 
         await db.init();
 
-        const cache = intializeDbCache(character, db);
+        const cache = initializeDbCache(character, db);
         const runtime = await createAgent(character, db, cache, token);
 
         await runtime.initialize();

packages/client-farcaster/src/interactions.ts

@@ -6,6 +6,8 @@ import {
     ModelClass,
     stringToUuid,
     elizaLogger,
+    HandlerCallback,
+    Content,
     type IAgentRuntime,
 } from "@ai16z/eliza";
 import type { FarcasterClient } from "./client";
@@ -219,56 +221,65 @@ export class FarcasterInteractionManager {
                 messageHandlerTemplate,
         });
 
-        const response = await generateMessageResponse({
+        const responseContent = await generateMessageResponse({
             runtime: this.runtime,
             context,
             modelClass: ModelClass.LARGE,
         });
 
-        response.inReplyTo = memoryId;
+        responseContent.inReplyTo = memoryId;
 
-        if (!response.text) return;
+        if (!responseContent.text) return;
 
         if (this.runtime.getSetting("FARCASTER_DRY_RUN") === "true") {
             elizaLogger.info(
-                `Dry run: would have responded to cast ${cast.hash} with ${response.text}`
+                `Dry run: would have responded to cast ${cast.hash} with ${responseContent.text}`
             );
             return;
         }
 
-        try {
-            elizaLogger.info(`Replying to cast ${cast.hash}.`);
-
-            const results = await sendCast({
-                runtime: this.runtime,
-                client: this.client,
-                signerUuid: this.signerUuid,
-                profile: cast.profile,
-                content: response,
-                roomId: memory.roomId,
-                inReplyTo: {
-                    fid: cast.authorFid,
-                    hash: cast.hash,
-                },
-            });
-            // sendCast lost response action, so we need to add it back here
-            results[0].memory.content.action = response.action;
-
-            const newState = await this.runtime.updateRecentMessageState(state);
-
-            for (const { memory } of results) {
-                await this.runtime.messageManager.createMemory(memory);
+        const callback: HandlerCallback = async (
+            content: Content,
+            files: any[]
+        ) => {
+            try {
+                if (memoryId && !content.inReplyTo) {
+                    content.inReplyTo = memoryId;
+                }
+                const results = await sendCast({
+                    runtime: this.runtime,
+                    client: this.client,
+                    signerUuid: this.signerUuid,
+                    profile: cast.profile,
+                    content: content,
+                    roomId: memory.roomId,
+                    inReplyTo: {
+                        fid: cast.authorFid,
+                        hash: cast.hash,
+                    },
+                });
+                // sendCast lost response action, so we need to add it back here
+                results[0].memory.content.action = content.action;
+
+                for (const { memory } of results) {
+                    await this.runtime.messageManager.createMemory(memory);
+                }
+                return results.map((result) => result.memory);
+            } catch (error) {
+                console.error("Error sending response cast:", error);
+                return [];
             }
+        };
 
-            await this.runtime.evaluate(memory, newState);
+        const responseMessages = await callback(responseContent);
 
-            await this.runtime.processActions(
-                memory,
-                results.map((result) => result.memory),
-                newState
-            );
-        } catch (error) {
-            elizaLogger.error(`Error sending response cast: ${error}`);
-        }
+        const newState = await this.runtime.updateRecentMessageState(state);
+
+        await this.runtime.processActions(
+            memory,
+            responseMessages,
+            newState,
+            callback
+        );
     }
 }