@elizaos/plugin-farcaster 1.0.2 → 1.0.5

package/dist/index.js

@@ -1,15 +1,25 @@
-// src/service.ts
-import { logger as logger6, Service } from "@elizaos/core";
+import {
+  sendCastAction
+} from "./chunk-OAXQ6Z2Q.js";
+import {
+  farcasterProfileProvider
+} from "./chunk-IOTLJXKN.js";
+import {
+  farcasterTimelineProvider
+} from "./chunk-FNDASAYG.js";
+import {
+  DEFAULT_CAST_CACHE_SIZE,
+  DEFAULT_CAST_CACHE_TTL,
+  DEFAULT_CAST_INTERVAL_MAX,
+  DEFAULT_CAST_INTERVAL_MIN,
+  DEFAULT_MAX_CAST_LENGTH,
+  DEFAULT_POLL_INTERVAL,
+  FARCASTER_SERVICE_NAME,
+  FARCASTER_SOURCE
+} from "./chunk-Y2URJ4EZ.js";
 
-// src/common/constants.ts
-var FARCASTER_SERVICE_NAME = "farcaster";
-var FARCASTER_SOURCE = "farcaster";
-var DEFAULT_MAX_CAST_LENGTH = 320;
-var DEFAULT_POLL_INTERVAL = 120;
-var DEFAULT_POST_INTERVAL_MIN = 90;
-var DEFAULT_POST_INTERVAL_MAX = 180;
-var DEFAULT_CAST_CACHE_TTL = 1e3 * 30 * 60;
-var DEFAULT_CAST_CACHE_SIZE = 9e3;
+// src/service.ts
+import { logger as logger8, Service } from "@elizaos/core";
 
 // src/managers/agent.ts
 import { logger as logger4 } from "@elizaos/core";
@@ -18,7 +28,7 @@ import { Configuration, NeynarAPIClient } from "@neynar/nodejs-sdk";
 // src/client.ts
 import { elizaLogger } from "@elizaos/core";
 import { isApiErrorResponse } from "@neynar/nodejs-sdk";
-import { CastParamType } from "@neynar/nodejs-sdk/build/api/models/cast-param-type";
+import { CastParamType } from "@neynar/nodejs-sdk/build/api/index.js";
 import { LRUCache } from "lru-cache";
 
 // src/common/utils.ts
@@ -33,30 +43,30 @@ function castUuid(props) {
 function splitPostContent(content, maxLength = MAX_CAST_LENGTH) {
   const paragraphs = content.split("\n\n").map((p) => p.trim());
   const posts = [];
-  let currentTweet = "";
+  let currentCast = "";
   for (const paragraph of paragraphs) {
     if (!paragraph) continue;
-    if ((currentTweet + "\n\n" + paragraph).trim().length <= maxLength) {
-      if (currentTweet) {
-        currentTweet += "\n\n" + paragraph;
+    if ((currentCast + "\n\n" + paragraph).trim().length <= maxLength) {
+      if (currentCast) {
+        currentCast += "\n\n" + paragraph;
       } else {
-        currentTweet = paragraph;
+        currentCast = paragraph;
       }
     } else {
-      if (currentTweet) {
-        posts.push(currentTweet.trim());
+      if (currentCast) {
+        posts.push(currentCast.trim());
       }
       if (paragraph.length <= maxLength) {
-        currentTweet = paragraph;
+        currentCast = paragraph;
       } else {
         const chunks = splitParagraph(paragraph, maxLength);
         posts.push(...chunks.slice(0, -1));
-        currentTweet = chunks[chunks.length - 1];
+        currentCast = chunks[chunks.length - 1];
       }
     }
   }
-  if (currentTweet) {
-    posts.push(currentTweet.trim());
+  if (currentCast) {
+    posts.push(currentCast.trim());
   }
   return posts;
 }
@@ -106,6 +116,7 @@ function lastCastCacheKey(fid) {
   return `farcaster/${fid}/lastCast`;
 }
 function neynarCastToCast(neynarCast) {
+  var _a;
   return {
     hash: neynarCast.hash,
     authorFid: neynarCast.author.fid,
@@ -116,7 +127,7 @@ function neynarCastToCast(neynarCast) {
       name: neynarCast.author.display_name || "anon",
       username: neynarCast.author.username
     },
-    ...neynarCast.parent_hash ? {
+    ...neynarCast.parent_hash && ((_a = neynarCast.parent_author) == null ? void 0 : _a.fid) ? {
       inReplyTo: {
         hash: neynarCast.parent_hash,
         fid: neynarCast.parent_author.fid
@@ -436,14 +447,14 @@ var FarcasterConfigSchema = z.object({
   FARCASTER_FID: z.number().int().min(1, "Farcaster fid is required"),
   MAX_CAST_LENGTH: z.number().int().default(DEFAULT_MAX_CAST_LENGTH),
   FARCASTER_POLL_INTERVAL: z.number().int().default(DEFAULT_POLL_INTERVAL),
-  ENABLE_POST: z.union([z.boolean(), z.string()]).transform((val) => typeof val === "string" ? val.toLowerCase() === "true" : val),
-  POST_INTERVAL_MIN: z.number().int(),
-  POST_INTERVAL_MAX: z.number().int(),
+  ENABLE_CAST: z.union([z.boolean(), z.string()]).transform((val) => typeof val === "string" ? val.toLowerCase() === "true" : val),
+  CAST_INTERVAL_MIN: z.number().int(),
+  CAST_INTERVAL_MAX: z.number().int(),
   ENABLE_ACTION_PROCESSING: z.union([z.boolean(), z.string()]).transform((val) => typeof val === "string" ? val.toLowerCase() === "true" : val),
   ACTION_INTERVAL: z.number().int(),
-  POST_IMMEDIATELY: z.union([z.boolean(), z.string()]).transform((val) => typeof val === "string" ? val.toLowerCase() === "true" : val),
+  CAST_IMMEDIATELY: z.union([z.boolean(), z.string()]).transform((val) => typeof val === "string" ? val.toLowerCase() === "true" : val),
   MAX_ACTIONS_PROCESSING: z.number().int(),
-  FARCASTER_NEYNAR_SIGNER_UUID: z.string().min(1, "FARCASTER_NEYNAR_SIGNER_UUID is not set"),
+  FARCASTER_SIGNER_UUID: z.string().min(1, "FARCASTER_SIGNER_UUID is not set"),
   FARCASTER_NEYNAR_API_KEY: z.string().min(1, "FARCASTER_NEYNAR_API_KEY is not set"),
   FARCASTER_HUB_URL: z.string().min(1, "FARCASTER_HUB_URL is not set")
 });
@@ -676,7 +687,7 @@ var FarcasterInteractionManager = class {
 
 // src/managers/post.ts
 import { createUniqueUuid as createUniqueUuid2, EventType as EventType2, logger as logger3 } from "@elizaos/core";
-var FarcasterPostManager = class {
+var FarcasterCastManager = class {
   client;
   runtime;
   fid;
@@ -690,7 +701,7 @@ var FarcasterPostManager = class {
     this.fid = this.config.FARCASTER_FID;
   }
   async start() {
-    if (this.isRunning || !this.config.ENABLE_POST) {
+    if (this.isRunning || !this.config.ENABLE_CAST) {
       return;
     }
     this.isRunning = true;
@@ -701,14 +712,14 @@ var FarcasterPostManager = class {
     this.isRunning = false;
   }
   calculateDelay() {
-    const minMinutes = this.config.POST_INTERVAL_MIN;
-    const maxMinutes = this.config.POST_INTERVAL_MAX;
+    const minMinutes = this.config.CAST_INTERVAL_MIN;
+    const maxMinutes = this.config.CAST_INTERVAL_MAX;
     const randomMinutes = Math.floor(Math.random() * (maxMinutes - minMinutes + 1)) + minMinutes;
     const delay = randomMinutes * 60 * 1e3;
     return { delay, randomMinutes };
   }
   async runPeriodically() {
-    if (this.config.POST_IMMEDIATELY) {
+    if (this.config.CAST_IMMEDIATELY) {
       await this.generateNewCast();
     }
     while (this.isRunning) {
@@ -722,7 +733,7 @@ var FarcasterPostManager = class {
         logger3.log(`Next cast scheduled in ${randomMinutes} minutes`);
         await new Promise((resolve) => this.timeout = setTimeout(resolve, delay));
       } catch (error) {
-        logger3.error("[Farcaster] Error in periodic post:", this.runtime.agentId, error);
+        logger3.error("[Farcaster] Error in periodic cast loop:", this.runtime.agentId, error);
       }
     }
   }
@@ -744,7 +755,7 @@ var FarcasterPostManager = class {
           });
         }
       });
-      this.runtime.emitEvent([EventType2.POST_GENERATED, "FARCASTER_POST_GENERATED" /* POST_GENERATED */], {
+      this.runtime.emitEvent([EventType2.POST_GENERATED, "FARCASTER_CAST_GENERATED" /* CAST_GENERATED */], {
         runtime: this.runtime,
         callback,
         worldId,
@@ -762,24 +773,24 @@ var FarcasterPostManager = class {
 var FarcasterAgentManager = class {
   runtime;
   client;
-  posts;
+  casts;
   interactions;
   constructor(runtime, config) {
     this.runtime = runtime;
-    const signerUuid = config.FARCASTER_NEYNAR_SIGNER_UUID;
+    const signerUuid = config.FARCASTER_SIGNER_UUID;
     const neynarConfig = new Configuration({ apiKey: config.FARCASTER_NEYNAR_API_KEY });
     const neynar = new NeynarAPIClient(neynarConfig);
     const client = new FarcasterClient({ neynar, signerUuid });
     this.client = client;
     logger4.success("Farcaster Neynar client initialized.");
-    this.posts = new FarcasterPostManager({ client, runtime, config });
+    this.casts = new FarcasterCastManager({ client, runtime, config });
     this.interactions = new FarcasterInteractionManager({ client, runtime, config });
   }
   async start() {
-    await Promise.all([this.posts.start(), this.interactions.start()]);
+    await Promise.all([this.casts.start(), this.interactions.start()]);
   }
   async stop() {
-    await Promise.all([this.posts.stop(), this.interactions.stop()]);
+    await Promise.all([this.casts.stop(), this.interactions.stop()]);
   }
 };
 
@@ -793,7 +804,7 @@ function safeParseInt(value, defaultValue) {
 }
 function hasFarcasterEnabled(runtime) {
   const fid = runtime.getSetting("FARCASTER_FID") || process.env.FARCASTER_FID;
-  const neynarSignerUuid = runtime.getSetting("FARCASTER_NEYNAR_SIGNER_UUID") || process.env.FARCASTER_NEYNAR_SIGNER_UUID;
+  const neynarSignerUuid = runtime.getSetting("FARCASTER_SIGNER_UUID") || process.env.FARCASTER_SIGNER_UUID;
   const neynarApiKey = runtime.getSetting("FARCASTER_NEYNAR_API_KEY") || process.env.FARCASTER_NEYNAR_API_KEY;
   return fid && neynarSignerUuid && neynarApiKey;
 }
@@ -811,14 +822,14 @@ function validateFarcasterConfig(runtime) {
         runtime.getSetting("FARCASTER_POLL_INTERVAL") || process.env.FARCASTER_POLL_INTERVAL,
         DEFAULT_POLL_INTERVAL
       ),
-      ENABLE_POST: runtime.getSetting("ENABLE_POST") || parseBooleanFromText(process.env.ENABLE_POST || "true"),
-      POST_INTERVAL_MIN: safeParseInt(
-        runtime.getSetting("POST_INTERVAL_MIN") || process.env.POST_INTERVAL_MIN,
-        DEFAULT_POST_INTERVAL_MIN
+      ENABLE_CAST: runtime.getSetting("ENABLE_CAST") || parseBooleanFromText(process.env.ENABLE_CAST || "true"),
+      CAST_INTERVAL_MIN: safeParseInt(
+        runtime.getSetting("CAST_INTERVAL_MIN") || process.env.CAST_INTERVAL_MIN,
+        DEFAULT_CAST_INTERVAL_MIN
       ),
-      POST_INTERVAL_MAX: safeParseInt(
-        runtime.getSetting("POST_INTERVAL_MAX") || process.env.POST_INTERVAL_MAX,
-        DEFAULT_POST_INTERVAL_MAX
+      CAST_INTERVAL_MAX: safeParseInt(
+        runtime.getSetting("CAST_INTERVAL_MAX") || process.env.CAST_INTERVAL_MAX,
+        DEFAULT_CAST_INTERVAL_MAX
       ),
       ENABLE_ACTION_PROCESSING: runtime.getSetting("ENABLE_ACTION_PROCESSING") || parseBooleanFromText(process.env.ENABLE_ACTION_PROCESSING || "false"),
       ACTION_INTERVAL: safeParseInt(
@@ -826,12 +837,12 @@ function validateFarcasterConfig(runtime) {
         5
       ),
       // 5 minutes
-      POST_IMMEDIATELY: runtime.getSetting("POST_IMMEDIATELY") || parseBooleanFromText(process.env.POST_IMMEDIATELY || "false"),
+      CAST_IMMEDIATELY: runtime.getSetting("CAST_IMMEDIATELY") || parseBooleanFromText(process.env.CAST_IMMEDIATELY || "false"),
       MAX_ACTIONS_PROCESSING: safeParseInt(
         runtime.getSetting("MAX_ACTIONS_PROCESSING") || process.env.MAX_ACTIONS_PROCESSING,
         1
       ),
-      FARCASTER_NEYNAR_SIGNER_UUID: runtime.getSetting("FARCASTER_NEYNAR_SIGNER_UUID") || process.env.FARCASTER_NEYNAR_SIGNER_UUID,
+      FARCASTER_SIGNER_UUID: runtime.getSetting("FARCASTER_SIGNER_UUID") || process.env.FARCASTER_SIGNER_UUID,
       FARCASTER_NEYNAR_API_KEY: runtime.getSetting("FARCASTER_NEYNAR_API_KEY") || process.env.FARCASTER_NEYNAR_API_KEY,
       FARCASTER_HUB_URL: runtime.getSetting("FARCASTER_HUB_URL") || process.env.FARCASTER_HUB_URL || "hub.pinata.cloud"
     };
@@ -840,12 +851,12 @@ function validateFarcasterConfig(runtime) {
     logger5.log("Farcaster Client Configuration:");
     logger5.log(`- FID: ${config.FARCASTER_FID}`);
     logger5.log(`- Dry Run Mode: ${isDryRun ? "enabled" : "disabled"}`);
-    logger5.log(`- Enable Post: ${config.ENABLE_POST ? "enabled" : "disabled"}`);
-    if (config.ENABLE_POST) {
+    logger5.log(`- Enable Cast: ${config.ENABLE_CAST ? "enabled" : "disabled"}`);
+    if (config.ENABLE_CAST) {
       logger5.log(
-        `- Post Interval: ${config.POST_INTERVAL_MIN}-${config.POST_INTERVAL_MAX} minutes`
+        `- Cast Interval: ${config.CAST_INTERVAL_MIN}-${config.CAST_INTERVAL_MAX} minutes`
       );
-      logger5.log(`- Post Immediately: ${config.POST_IMMEDIATELY ? "enabled" : "disabled"}`);
+      logger5.log(`- Cast Immediately: ${config.CAST_IMMEDIATELY ? "enabled" : "disabled"}`);
     }
     logger5.log(`- Action Processing: ${config.ENABLE_ACTION_PROCESSING ? "enabled" : "disabled"}`);
     logger5.log(`- Action Interval: ${config.ACTION_INTERVAL} minutes`);
@@ -863,11 +874,389 @@ ${errorMessages}`);
   }
 }
 
+// src/services/MessageService.ts
+import {
+  logger as logger6,
+  createUniqueUuid as createUniqueUuid3
+} from "@elizaos/core";
+var FarcasterMessageService = class {
+  constructor(client, runtime) {
+    this.client = client;
+    this.runtime = runtime;
+  }
+  async getMessages(options) {
+    try {
+      const { roomId, limit = 20 } = options;
+      const { timeline } = await this.client.getTimeline({
+        fid: parseInt(
+          this.runtime.getSetting("FARCASTER_FID") || this.runtime.config.FARCASTER_FID
+        ),
+        pageSize: limit
+      });
+      const messages = timeline.filter((cast) => {
+        if (roomId) {
+          const castRoomId = createUniqueUuid3(this.runtime, cast.threadId || cast.hash);
+          return castRoomId === roomId;
+        }
+        return true;
+      }).map((cast) => ({
+        id: castUuid({ hash: cast.hash, agentId: this.runtime.agentId }),
+        agentId: this.runtime.agentId,
+        roomId: createUniqueUuid3(this.runtime, cast.threadId || cast.hash),
+        userId: cast.profile.fid.toString(),
+        username: cast.profile.username,
+        text: cast.text,
+        type: cast.inReplyTo ? "REPLY" /* REPLY */ : "CAST" /* CAST */,
+        timestamp: cast.timestamp.getTime(),
+        inReplyTo: cast.inReplyTo ? castUuid({ hash: cast.inReplyTo.hash, agentId: this.runtime.agentId }) : void 0,
+        metadata: {
+          castHash: cast.hash,
+          threadId: cast.threadId,
+          authorFid: cast.authorFid
+        }
+      }));
+      return messages;
+    } catch (error) {
+      logger6.error("[Farcaster] Error fetching messages:", error);
+      return [];
+    }
+  }
+  async sendMessage(options) {
+    var _a;
+    try {
+      const { text, type, roomId, replyToId, agentId } = options;
+      let inReplyTo = void 0;
+      if (replyToId && type === "REPLY" /* REPLY */) {
+        const parentHash = ((_a = options.metadata) == null ? void 0 : _a.parentHash) || replyToId;
+        inReplyTo = {
+          hash: parentHash,
+          fid: parseInt(
+            this.runtime.getSetting("FARCASTER_FID") || this.runtime.config.FARCASTER_FID
+          )
+        };
+      }
+      const casts = await this.client.sendCast({
+        content: { text },
+        inReplyTo
+      });
+      if (casts.length === 0) {
+        throw new Error("No cast was created");
+      }
+      const cast = neynarCastToCast(casts[0]);
+      const message = {
+        id: castUuid({ hash: cast.hash, agentId }),
+        agentId,
+        roomId,
+        userId: cast.profile.fid.toString(),
+        username: cast.profile.username,
+        text: cast.text,
+        type,
+        timestamp: cast.timestamp.getTime(),
+        inReplyTo: inReplyTo ? castUuid({ hash: inReplyTo.hash, agentId }) : void 0,
+        metadata: {
+          ...options.metadata,
+          castHash: cast.hash,
+          threadId: cast.threadId,
+          authorFid: cast.authorFid
+        }
+      };
+      await this.runtime.emitEvent("FARCASTER_CAST_GENERATED" /* CAST_GENERATED */, {
+        runtime: this.runtime,
+        castHash: cast.hash,
+        message,
+        threadId: cast.threadId
+      });
+      return message;
+    } catch (error) {
+      logger6.error("[Farcaster] Error sending message:", error);
+      throw error;
+    }
+  }
+  async deleteMessage(messageId, agentId) {
+    logger6.warn("[Farcaster] Cast deletion is not supported by the Farcaster API");
+  }
+  async getMessage(messageId, agentId) {
+    try {
+      const castHash = messageId;
+      const cast = await this.client.getCast(castHash);
+      const farcasterCast = neynarCastToCast(cast);
+      const message = {
+        id: castUuid({ hash: farcasterCast.hash, agentId }),
+        agentId,
+        roomId: createUniqueUuid3(this.runtime, farcasterCast.threadId || farcasterCast.hash),
+        userId: farcasterCast.profile.fid.toString(),
+        username: farcasterCast.profile.username,
+        text: farcasterCast.text,
+        type: farcasterCast.inReplyTo ? "REPLY" /* REPLY */ : "CAST" /* CAST */,
+        timestamp: farcasterCast.timestamp.getTime(),
+        inReplyTo: farcasterCast.inReplyTo ? castUuid({ hash: farcasterCast.inReplyTo.hash, agentId }) : void 0,
+        metadata: {
+          castHash: farcasterCast.hash,
+          threadId: farcasterCast.threadId,
+          authorFid: farcasterCast.authorFid
+        }
+      };
+      return message;
+    } catch (error) {
+      logger6.error("[Farcaster] Error fetching message:", error);
+      return null;
+    }
+  }
+  async markAsRead(messageIds, agentId) {
+    logger6.debug("[Farcaster] Mark as read is not applicable for Farcaster casts");
+  }
+};
+
+// src/services/CastService.ts
+import {
+  logger as logger7,
+  ModelType as ModelType2,
+  createUniqueUuid as createUniqueUuid4
+} from "@elizaos/core";
+var FarcasterCastService = class {
+  constructor(client, runtime) {
+    this.client = client;
+    this.runtime = runtime;
+  }
+  static serviceType = "ICastService";
+  /**
+   * Get recent casts from the timeline
+   */
+  async getCasts(params) {
+    var _a, _b;
+    try {
+      const { timeline } = await this.client.getTimeline({
+        fid: ((_a = this.runtime.config) == null ? void 0 : _a.FARCASTER_FID) || ((_b = this.runtime.settings) == null ? void 0 : _b.FARCASTER_FID),
+        pageSize: params.limit || 50
+      });
+      return timeline.map((cast) => this.castToFarcasterCast(cast, params.agentId));
+    } catch (error) {
+      logger7.error("Failed to get casts", { params, error });
+      return [];
+    }
+  }
+  /**
+   * Create a new cast
+   */
+  async createCast(params) {
+    var _a;
+    try {
+      let castText = params.text;
+      if (!castText || castText.trim() === "") {
+        castText = await this.generateCastContent();
+      }
+      if (castText.length > 320) {
+        castText = await this.truncateCast(castText);
+      }
+      const casts = await this.client.sendCast({
+        content: { text: castText },
+        inReplyTo: params.replyTo ? { hash: params.replyTo.hash, fid: params.replyTo.fid } : void 0
+      });
+      if (casts.length === 0) {
+        throw new Error("No cast was created");
+      }
+      const cast = neynarCastToCast(casts[0]);
+      const farcasterCast = {
+        id: castUuid({ hash: cast.hash, agentId: params.agentId }),
+        agentId: params.agentId,
+        roomId: params.roomId,
+        userId: cast.profile.fid.toString(),
+        username: cast.profile.username,
+        text: cast.text,
+        timestamp: cast.timestamp.getTime(),
+        inReplyTo: (_a = params.replyTo) == null ? void 0 : _a.hash,
+        media: [],
+        // TODO: Handle media upload when Farcaster API supports it
+        metadata: {
+          castHash: cast.hash,
+          threadId: cast.threadId,
+          authorFid: cast.authorFid,
+          source: FARCASTER_SOURCE
+        }
+      };
+      await this.storeCastInMemory(params.roomId, farcasterCast);
+      return farcasterCast;
+    } catch (error) {
+      logger7.error("Failed to create cast", { params, error });
+      throw error;
+    }
+  }
+  /**
+   * Delete a cast
+   */
+  async deleteCast(params) {
+    try {
+      logger7.warn("Cast deletion is not supported by the Farcaster API", { castHash: params.castHash });
+    } catch (error) {
+      logger7.error("Failed to delete cast", { params, error });
+      throw error;
+    }
+  }
+  /**
+   * Like a cast
+   */
+  async likeCast(params) {
+    try {
+      logger7.info("Like functionality not yet implemented for cast", { castHash: params.castHash });
+    } catch (error) {
+      logger7.error("Failed to like cast", { params, error });
+      throw error;
+    }
+  }
+  /**
+   * Unlike a cast
+   */
+  async unlikeCast(params) {
+    try {
+      logger7.info("Unlike functionality not yet implemented for cast", { castHash: params.castHash });
+    } catch (error) {
+      logger7.error("Failed to unlike cast", { params, error });
+      throw error;
+    }
+  }
+  /**
+   * Recast a cast
+   */
+  async recast(params) {
+    try {
+      logger7.info("Recast functionality not yet implemented for cast", { castHash: params.castHash });
+    } catch (error) {
+      logger7.error("Failed to recast", { params, error });
+      throw error;
+    }
+  }
+  /**
+   * Remove a recast
+   */
+  async unrecast(params) {
+    try {
+      logger7.info("Remove recast functionality not yet implemented for cast", { castHash: params.castHash });
+    } catch (error) {
+      logger7.error("Failed to remove recast", { params, error });
+      throw error;
+    }
+  }
+  /**
+   * Get mentions
+   */
+  async getMentions(params) {
+    var _a, _b;
+    try {
+      const mentions = await this.client.getMentions({
+        fid: ((_a = this.runtime.config) == null ? void 0 : _a.FARCASTER_FID) || ((_b = this.runtime.settings) == null ? void 0 : _b.FARCASTER_FID),
+        pageSize: params.limit || 20
+      });
+      return mentions.map((castWithInteractions) => {
+        const cast = neynarCastToCast(castWithInteractions);
+        return this.castToFarcasterCast(cast, params.agentId);
+      });
+    } catch (error) {
+      logger7.error("Failed to get mentions", { params, error });
+      return [];
+    }
+  }
+  /**
+   * Generate cast content using AI
+   */
+  async generateCastContent() {
+    const prompt = `Generate an interesting and engaging Farcaster cast. It should be conversational, authentic, and under 320 characters. Topics can include technology, AI, crypto, decentralized social media, or general observations about life.`;
+    try {
+      const response = await this.runtime.useModel(ModelType2.TEXT_SMALL, {
+        prompt,
+        maxTokens: 100
+      });
+      return response;
+    } catch (error) {
+      logger7.error("Failed to generate cast content", { error });
+      return "Hello Farcaster! \u{1F44B}";
+    }
+  }
+  /**
+   * Truncate cast to fit character limit
+   */
+  async truncateCast(text) {
+    const prompt = `Shorten this text to under 320 characters while keeping the main message intact: "${text}"`;
+    try {
+      const response = await this.runtime.useModel(ModelType2.TEXT_SMALL, {
+        prompt,
+        maxTokens: 100
+      });
+      const truncated = response;
+      if (truncated.length > 320) {
+        return truncated.substring(0, 317) + "...";
+      }
+      return truncated;
+    } catch (error) {
+      logger7.error("Failed to truncate cast", { error });
+      return text.substring(0, 317) + "...";
+    }
+  }
+  /**
+   * Store cast in agent memory
+   */
+  async storeCastInMemory(roomId, cast) {
+    var _a;
+    try {
+      const memory = {
+        id: createUniqueUuid4(this.runtime, cast.id),
+        agentId: this.runtime.agentId,
+        content: {
+          text: cast.text,
+          castHash: (_a = cast.metadata) == null ? void 0 : _a.castHash,
+          castId: cast.id,
+          author: cast.username,
+          timestamp: cast.timestamp
+        },
+        roomId,
+        userId: cast.userId,
+        createdAt: Date.now()
+      };
+      if (typeof this.runtime.storeMemory === "function") {
+        await this.runtime.storeMemory(memory);
+      } else if (this.runtime.memory && typeof this.runtime.memory.create === "function") {
+        await this.runtime.memory.create(memory);
+      } else {
+        logger7.warn("Memory storage method not available in runtime");
+      }
+    } catch (error) {
+      logger7.error("Failed to store cast in memory", { error });
+    }
+  }
+  /**
+   * Convert internal Cast type to FarcasterCast
+   */
+  castToFarcasterCast(cast, agentId) {
+    return {
+      id: castUuid({ hash: cast.hash, agentId }),
+      agentId,
+      roomId: createUniqueUuid4(this.runtime, cast.threadId || cast.hash),
+      userId: cast.profile.fid.toString(),
+      username: cast.profile.username,
+      text: cast.text,
+      timestamp: cast.timestamp.getTime(),
+      media: [],
+      // Farcaster casts can have embedded media but not in our Cast type
+      metadata: {
+        castHash: cast.hash,
+        threadId: cast.threadId,
+        authorFid: cast.authorFid,
+        source: FARCASTER_SOURCE,
+        stats: cast.stats
+      }
+    };
+  }
+};
+
 // src/service.ts
 var FarcasterService = class _FarcasterService extends Service {
   static instance;
   managers = /* @__PURE__ */ new Map();
+  messageServices = /* @__PURE__ */ new Map();
+  castServices = /* @__PURE__ */ new Map();
+  // Properly implement serviceType for discoverability
   static serviceType = FARCASTER_SERVICE_NAME;
+  // Add service description
+  description = "Farcaster integration service for sending and receiving casts";
   capabilityDescription = "The agent is able to send and receive messages on farcaster";
   static getInstance() {
     if (!_FarcasterService.instance) {
@@ -875,23 +1264,31 @@ var FarcasterService = class _FarcasterService extends Service {
     }
     return _FarcasterService.instance;
   }
+  // Required by ElizaOS Service base class
+  async initialize(runtime) {
+    await _FarcasterService.start(runtime);
+  }
   // Called to start a single Farcaster service
   static async start(runtime) {
     const service = _FarcasterService.getInstance();
     let manager = service.managers.get(runtime.agentId);
     if (manager) {
-      logger6.warn("Farcaster service already started", runtime.agentId);
+      logger8.warn("Farcaster service already started", runtime.agentId);
       return service;
     }
     if (!hasFarcasterEnabled(runtime)) {
-      logger6.debug("Farcaster service not enabled", runtime.agentId);
+      logger8.debug("Farcaster service not enabled", runtime.agentId);
       return service;
     }
     const farcasterConfig = validateFarcasterConfig(runtime);
     manager = new FarcasterAgentManager(runtime, farcasterConfig);
     service.managers.set(runtime.agentId, manager);
+    const messageService = new FarcasterMessageService(manager.client, runtime);
+    const castService = new FarcasterCastService(manager.client, runtime);
+    service.messageServices.set(runtime.agentId, messageService);
+    service.castServices.set(runtime.agentId, castService);
     await manager.start();
-    logger6.success("Farcaster client started", runtime.agentId);
+    logger8.success("Farcaster client started", runtime.agentId);
     return service;
   }
   // Called to stop a single Farcaster service
@@ -901,33 +1298,84 @@ var FarcasterService = class _FarcasterService extends Service {
     if (manager) {
       await manager.stop();
       service.managers.delete(runtime.agentId);
-      logger6.info("Farcaster client stopped", runtime.agentId);
+      service.messageServices.delete(runtime.agentId);
+      service.castServices.delete(runtime.agentId);
+      logger8.info("Farcaster client stopped", runtime.agentId);
     } else {
-      logger6.debug("Farcaster service not running", runtime.agentId);
+      logger8.debug("Farcaster service not running", runtime.agentId);
     }
   }
   // Called to stop all Farcaster services
   async stop() {
-    logger6.debug("Stopping ALL Farcaster services");
+    logger8.debug("Stopping ALL Farcaster services");
     for (const manager of Array.from(this.managers.values())) {
       const agentId = manager.runtime.agentId;
       try {
         await _FarcasterService.stop(manager.runtime);
       } catch (error) {
-        logger6.error("Error stopping Farcaster service", agentId, error);
+        logger8.error("Error stopping Farcaster service", agentId, error);
       }
     }
   }
+  // Get the MessageService for a specific agent
+  getMessageService(agentId) {
+    return this.messageServices.get(agentId);
+  }
+  /**
+   * Get the PostService for a specific agent (for compatibility)
+   * @deprecated Use getCastService() instead. Will be removed in a future major release.
+   */
+  getPostService(agentId) {
+    return this.castServices.get(agentId);
+  }
+  // Get the CastService for a specific agent  
+  getCastService(agentId) {
+    return this.castServices.get(agentId);
+  }
+  // Add health check method
+  async healthCheck() {
+    const managerStatuses = {};
+    let overallHealthy = true;
+    for (const [agentId, manager] of Array.from(this.managers.entries())) {
+      try {
+        const profile = await manager.client.getProfile(
+          parseInt(manager.runtime.getSetting("FARCASTER_FID"))
+        );
+        managerStatuses[agentId] = {
+          status: "healthy",
+          fid: profile.fid,
+          username: profile.username
+        };
+      } catch (error) {
+        managerStatuses[agentId] = {
+          status: "unhealthy",
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+        overallHealthy = false;
+      }
+    }
+    return {
+      healthy: overallHealthy,
+      details: {
+        activeManagers: this.managers.size,
+        managerStatuses
+      }
+    };
+  }
+  // Get all active managers (for monitoring)
+  getActiveManagers() {
+    return new Map(this.managers);
+  }
 };
 
-// __tests__/suite.ts
+// src/__tests__/suite.ts
 import {
-  ModelType as ModelType2,
-  createUniqueUuid as createUniqueUuid3,
-  logger as logger7
+  ModelType as ModelType3,
+  createUniqueUuid as createUniqueUuid6,
+  logger as logger10
 } from "@elizaos/core";
 
-// __tests__/test-utils.ts
+// src/__tests__/test-utils.ts
 var TEST_IMAGE_URL = "https://github.com/elizaOS/awesome-eliza/blob/main/assets/eliza-logo.jpg?raw=true";
 var TEST_IMAGE = {
   id: "mock-image-id",
@@ -940,9 +1388,276 @@ var TEST_IMAGE = {
   alt_text: "mock image"
 };
 
-// __tests__/suite.ts
+// src/__tests__/e2e/scenarios.ts
+import { logger as logger9, createUniqueUuid as createUniqueUuid5 } from "@elizaos/core";
+var farcasterE2EScenarios = [
+  {
+    name: "Farcaster Plugin - Agent Introduction",
+    async fn(runtime) {
+      var _a;
+      const service = runtime.getService(FARCASTER_SERVICE_NAME);
+      if (!service) {
+        throw new Error("Farcaster service not initialized");
+      }
+      const postService = service.getPostService(runtime.agentId);
+      if (!postService) {
+        throw new Error("PostService not available");
+      }
+      const introText = `Hello Farcaster! I'm ${runtime.character.name}, an AI agent powered by ElizaOS. Looking forward to connecting with you all! \u{1F916}`;
+      const cast = await postService.createPost({
+        agentId: runtime.agentId,
+        roomId: createUniqueUuid5(runtime, "farcaster-timeline"),
+        text: introText
+      });
+      if (!cast || !cast.id || !cast.text || !((_a = cast.metadata) == null ? void 0 : _a.castHash)) {
+        throw new Error("Failed to create introduction cast");
+      }
+      logger9.info(`Posted introduction cast: ${cast.metadata.castHash}`);
+      const manager = service.getActiveManagers().get(runtime.agentId);
+      if (!manager) {
+        throw new Error("Manager not found for agent");
+      }
+      const fid = parseInt(runtime.getSetting("FARCASTER_FID"));
+      const profile = await manager.client.getProfile(fid);
+      if (!profile || profile.fid !== fid) {
+        throw new Error("Profile fetch failed or FID mismatch");
+      }
+      logger9.info(`Agent profile verified: @${profile.username} (FID: ${profile.fid})`);
+    }
+  },
+  {
+    name: "Farcaster Plugin - Timeline Monitoring",
+    async fn(runtime) {
+      const service = runtime.getService(FARCASTER_SERVICE_NAME);
+      if (!service) {
+        throw new Error("Farcaster service not initialized");
+      }
+      const postService = service.getPostService(runtime.agentId);
+      if (!postService) {
+        throw new Error("PostService not available");
+      }
+      const casts = await postService.getPosts({
+        agentId: runtime.agentId,
+        limit: 10
+      });
+      if (!Array.isArray(casts)) {
+        throw new Error("getPosts did not return an array");
+      }
+      logger9.info(`Found ${casts.length} casts in timeline`);
+      if (casts.length > 0) {
+        const firstCast = casts[0];
+        if (!firstCast.id || !firstCast.username || !firstCast.text) {
+          throw new Error("Cast missing required fields");
+        }
+        logger9.info(`Latest cast by @${firstCast.username}: ${firstCast.text.substring(0, 50)}...`);
+      }
+      const mentions = await postService.getMentions(runtime.agentId, { limit: 5 });
+      if (!Array.isArray(mentions)) {
+        throw new Error("getMentions did not return an array");
+      }
+      logger9.info(`Found ${mentions.length} mentions`);
+    }
+  },
+  {
+    name: "Farcaster Plugin - Message Send and Retrieve",
+    async fn(runtime) {
+      var _a;
+      const service = runtime.getService(FARCASTER_SERVICE_NAME);
+      if (!service) {
+        throw new Error("Farcaster service not initialized");
+      }
+      const messageService = service.getMessageService(runtime.agentId);
+      if (!messageService) {
+        throw new Error("MessageService not available");
+      }
+      const roomId = createUniqueUuid5(runtime, "test-conversation");
+      const message = await messageService.sendMessage({
+        agentId: runtime.agentId,
+        roomId,
+        text: "Testing message send and retrieve with ElizaOS Farcaster plugin! \u{1F9EA}",
+        type: "CAST" /* CAST */
+      });
+      if (!message || !message.id || !((_a = message.metadata) == null ? void 0 : _a.castHash)) {
+        throw new Error("Failed to send message or missing metadata");
+      }
+      logger9.info(`Sent cast with hash: ${message.metadata.castHash}`);
+      const castHash = message.metadata.castHash;
+      const retrieved = await messageService.getMessage(castHash, runtime.agentId);
+      if (!retrieved || retrieved.text !== message.text) {
+        throw new Error("Failed to retrieve message or content mismatch");
+      }
+      logger9.info("Successfully retrieved message by hash");
+    }
+  },
+  {
+    name: "Farcaster Plugin - Reply Threading",
+    async fn(runtime) {
+      var _a, _b;
+      const service = runtime.getService(FARCASTER_SERVICE_NAME);
+      if (!service) {
+        throw new Error("Farcaster service not initialized");
+      }
+      const messageService = service.getMessageService(runtime.agentId);
+      const postService = service.getPostService(runtime.agentId);
+      if (!messageService || !postService) {
+        throw new Error("Services not available");
+      }
+      const originalCast = await postService.createPost({
+        agentId: runtime.agentId,
+        roomId: createUniqueUuid5(runtime, "reply-test"),
+        text: "This is a test cast for reply threading \u{1F9F5}"
+      });
+      if (!originalCast || !((_a = originalCast.metadata) == null ? void 0 : _a.castHash)) {
+        throw new Error("Failed to create original cast");
+      }
+      const reply = await messageService.sendMessage({
+        agentId: runtime.agentId,
+        roomId: originalCast.roomId,
+        text: "This is a test reply maintaining thread context! \u{1F4AC}",
+        type: "REPLY",
+        replyToId: originalCast.metadata.castHash,
+        metadata: {
+          parentHash: originalCast.metadata.castHash
+        }
+      });
+      if (!reply || !reply.inReplyTo || !((_b = reply.metadata) == null ? void 0 : _b.castHash)) {
+        throw new Error("Failed to create reply or missing thread context");
+      }
+      logger9.info(`Created reply ${reply.metadata.castHash} to ${originalCast.metadata.castHash}`);
+    }
+  },
+  {
+    name: "Farcaster Plugin - Action Execution",
+    async fn(runtime) {
+      const { sendCastAction: sendCastAction2 } = await import("./sendCast-OW6DBKQB.js");
+      const mockMessage = {
+        id: createUniqueUuid5(runtime, "test-message"),
+        agentId: runtime.agentId,
+        roomId: createUniqueUuid5(runtime, "test-room"),
+        entityId: runtime.agentId,
+        content: {
+          text: "Can you post about the ElizaOS framework on Farcaster?"
+        },
+        createdAt: Date.now()
+      };
+      const shouldExecute = await sendCastAction2.validate(runtime, mockMessage);
+      if (!shouldExecute) {
+        throw new Error("SEND_CAST action validation failed");
+      }
+      const result = await sendCastAction2.handler(runtime, mockMessage);
+      if (!result) {
+        throw new Error("SEND_CAST action execution failed");
+      }
+      logger9.info("Successfully validated and executed SEND_CAST action");
+    }
+  },
+  {
+    name: "Farcaster Plugin - Provider Context",
+    async fn(runtime) {
+      var _a, _b;
+      const { farcasterProfileProvider: farcasterProfileProvider2 } = await import("./profileProvider-TNRU42OO.js");
+      const { farcasterTimelineProvider: farcasterTimelineProvider2 } = await import("./timelineProvider-GPRPFEVJ.js");
+      const mockMessage = {
+        id: createUniqueUuid5(runtime, "test-message"),
+        agentId: runtime.agentId,
+        roomId: createUniqueUuid5(runtime, "test-room"),
+        entityId: runtime.agentId,
+        content: { text: "test" },
+        createdAt: Date.now()
+      };
+      const profileContext = await farcasterProfileProvider2.get(runtime, mockMessage, { values: [], data: {}, text: "" });
+      if (!profileContext || !profileContext.text || ((_a = profileContext.data) == null ? void 0 : _a.available) === void 0) {
+        throw new Error("Profile provider returned invalid context");
+      }
+      logger9.info(`Profile provider: ${profileContext.text}`);
+      const timelineContext = await farcasterTimelineProvider2.get(runtime, mockMessage, { values: [], data: {}, text: "" });
+      if (!timelineContext || !timelineContext.text || ((_b = timelineContext.data) == null ? void 0 : _b.available) === void 0) {
+        throw new Error("Timeline provider returned invalid context");
+      }
+      logger9.info(`Timeline provider: ${timelineContext.text}`);
+    }
+  },
+  {
+    name: "Farcaster Plugin - Rate Limit Handling",
+    async fn(runtime) {
+      const service = runtime.getService(FARCASTER_SERVICE_NAME);
+      if (!service) {
+        throw new Error("Farcaster service not initialized");
+      }
+      const messageService = service.getMessageService(runtime.agentId);
+      if (!messageService) {
+        throw new Error("MessageService not available");
+      }
+      const promises = [];
+      for (let i = 0; i < 3; i++) {
+        promises.push(
+          messageService.sendMessage({
+            agentId: runtime.agentId,
+            roomId: createUniqueUuid5(runtime, "rate-limit-test"),
+            text: `Rate limit test message ${i + 1}`,
+            type: "CAST" /* CAST */
+          }).catch((error) => {
+            logger9.warn(`Expected rate limit error: ${error.message}`);
+            return null;
+          })
+        );
+      }
+      const results = await Promise.all(promises);
+      const successfulSends = results.filter((r) => r !== null);
+      if (successfulSends.length === 0) {
+        throw new Error("All messages failed - check if rate limiting is too strict");
+      }
+      logger9.info(`Successfully sent ${successfulSends.length} out of ${promises.length} messages`);
+    }
+  },
+  {
+    name: "Farcaster Plugin - Service Health Check",
+    async fn(runtime) {
+      const service = runtime.getService(FARCASTER_SERVICE_NAME);
+      if (!service) {
+        throw new Error("Farcaster service not initialized");
+      }
+      const health = await service.healthCheck();
+      if (!health || health.healthy === void 0 || !health.details) {
+        throw new Error("Health check returned invalid data");
+      }
+      logger9.info(`Service health: ${health.healthy ? "Healthy" : "Unhealthy"}`);
+      logger9.info(`Active managers: ${health.details.activeManagers}`);
+      if (!health.healthy) {
+        logger9.warn("Service reported unhealthy status:", health.details);
+      }
+    }
+  },
+  {
+    name: "Farcaster Plugin - Should Send a Real Cast",
+    async fn(runtime) {
+      const service = runtime.getService(FARCASTER_SERVICE_NAME);
+      if (!service) {
+        throw new Error("FarcasterService not found");
+      }
+      const postService = service.getPostService(runtime.agentId);
+      if (!postService) {
+        throw new Error("PostService not available");
+      }
+      const uniqueMessage = `This is a real E2E test cast from ElizaOS! ID: ${createUniqueUuid5(runtime, "e2e-cast")}`;
+      logger9.info(`Attempting to post cast: "${uniqueMessage}"`);
+      const cast = await postService.createPost({
+        agentId: runtime.agentId,
+        roomId: createUniqueUuid5(runtime, "farcaster-e2e-test"),
+        text: uniqueMessage
+      });
+      if (!cast || !cast.id) {
+        throw new Error("E2E test failed to create a real cast.");
+      }
+      logger9.success(`Successfully posted E2E test cast with ID: ${cast.id}`);
+    }
+  }
+];
+
+// src/__tests__/suite.ts
 var FarcasterTestSuite = class {
-  name = "farcaster";
+  name = "Farcaster Plugin Tests";
+  description = "Test suite for Farcaster plugin functionality";
   manager = null;
   tests;
   /**
@@ -950,23 +1665,76 @@ var FarcasterTestSuite = class {
    * Initializes an array of test functions to be executed.
    */
   constructor() {
-    this.tests = [
-      {
-        name: "Initialize Farcaster Client",
-        fn: this.testInitializingClient.bind(this)
-      },
-      { name: "Fetch Profile", fn: this.testFetchProfile.bind(this) },
-      {
-        name: "Fetch Timeline",
-        fn: this.testFetchTimeline.bind(this)
-      },
-      { name: "Post Cast", fn: this.testPostCast.bind(this) },
-      { name: "Post Cast With Image", fn: this.testPostImageCast.bind(this) },
-      {
-        name: "Handle Cast Response",
-        fn: this.testHandleCastResponse.bind(this)
+    const hasRealCredentials = !!(process.env.FARCASTER_FID && process.env.FARCASTER_SIGNER_UUID && process.env.FARCASTER_NEYNAR_API_KEY);
+    logger10.info("=== Farcaster Test Suite Configuration ===");
+    logger10.info(`FID: ${process.env.FARCASTER_FID ? "\u2713 Found" : "\u2717 Missing"}`);
+    logger10.info(`Signer UUID: ${process.env.FARCASTER_SIGNER_UUID ? "\u2713 Found" : "\u2717 Missing"}`);
+    logger10.info(`API Key: ${process.env.FARCASTER_NEYNAR_API_KEY ? "\u2713 Found" : "\u2717 Missing"}`);
+    logger10.info(`Dry Run: ${process.env.FARCASTER_DRY_RUN || "not set (defaults to false)"}`);
+    logger10.info("=========================================");
+    if (hasRealCredentials) {
+      logger10.success("\u2705 Running with real Farcaster credentials");
+      this.tests = farcasterE2EScenarios;
+    } else {
+      logger10.warn("\u26A0\uFE0F  Farcaster credentials not found in environment variables");
+      logger10.warn("\u26A0\uFE0F  Tests will run in mock mode");
+      logger10.warn("\u26A0\uFE0F  To run real tests, set FARCASTER_FID, FARCASTER_SIGNER_UUID, and FARCASTER_NEYNAR_API_KEY");
+      this.tests = [
+        {
+          name: "Mock: Check Farcaster Configuration",
+          fn: this.testMockConfiguration.bind(this)
+        },
+        {
+          name: "Mock: Service Initialization",
+          fn: this.testMockServiceInit.bind(this)
+        }
+      ];
+    }
+  }
+  /**
+   * Test that checks if Farcaster is properly configured
+   */
+  async testMockConfiguration(runtime) {
+    logger10.info("Running mock configuration test");
+    const fid = runtime.getSetting("FARCASTER_FID");
+    const signerUuid = runtime.getSetting("FARCASTER_SIGNER_UUID");
+    const apiKey = runtime.getSetting("FARCASTER_NEYNAR_API_KEY");
+    logger10.info("Runtime settings check:");
+    logger10.info(`- FID from runtime: ${fid ? "Found" : "Not found"}`);
+    logger10.info(`- Signer UUID from runtime: ${signerUuid ? "Found" : "Not found"}`);
+    logger10.info(`- API Key from runtime: ${apiKey ? "Found" : "Not found"}`);
+    if (!fid || !signerUuid || !apiKey) {
+      logger10.info("Farcaster not configured - this is expected in mock mode");
+      logger10.info("To enable real tests, configure the following:");
+      logger10.info("- FARCASTER_FID: Your Farcaster ID");
+      logger10.info("- FARCASTER_SIGNER_UUID: Neynar signer UUID");
+      logger10.info("- FARCASTER_NEYNAR_API_KEY: Neynar API key");
+    }
+  }
+  /**
+   * Test service initialization without real credentials
+   */
+  async testMockServiceInit(runtime) {
+    logger10.info("Running mock service initialization test");
+    try {
+      const service = runtime.getService(FARCASTER_SERVICE_NAME);
+      if (!service) {
+        logger10.info("Farcaster service not available - this is expected without credentials");
+        return;
+      }
+      logger10.info("Farcaster service is registered but may not be fully initialized");
+      if (typeof service.getMessageService === "function") {
+        logger10.info("\u2713 getMessageService method exists");
+      }
+      if (typeof service.getPostService === "function") {
+        logger10.info("\u2713 getPostService method exists");
+      }
+      if (typeof service.healthCheck === "function") {
+        logger10.info("\u2713 healthCheck method exists");
       }
-    ];
+    } catch (error) {
+      logger10.info("Service initialization check completed");
+    }
   }
   /**
    * Asynchronously initializes the Farcaster client for the provided agent runtime.
@@ -982,7 +1750,7 @@ var FarcasterTestSuite = class {
       }
       this.manager = service.managers.get(runtime.agentId);
       if (this.manager) {
-        logger7.debug("FarcasterAgentManager initialized successfully.");
+        logger10.debug("FarcasterAgentManager initialized successfully.");
       } else {
         throw new Error("FarcasterAgentManager failed to initialize.");
       }
@@ -1009,7 +1777,7 @@ var FarcasterTestSuite = class {
       if (!profile || !profile.fid) {
         throw new Error("Profile fetch failed.");
       }
-      logger7.log("Successfully fetched Farcaster profile:", profile);
+      logger10.log("Successfully fetched Farcaster profile:", profile);
     } catch (error) {
       throw new Error(`Error fetching Farcaster profile: ${error}`);
     }
@@ -1035,7 +1803,7 @@ var FarcasterTestSuite = class {
       if (!result.timeline || result.timeline.length === 0) {
         throw new Error("No casts in timeline.");
       }
-      logger7.log(`Successfully fetched ${result.timeline.length} casts from timeline.`);
+      logger10.log(`Successfully fetched ${result.timeline.length} casts from timeline.`);
     } catch (error) {
       throw new Error(`Error fetching timeline: ${error}`);
     }
@@ -1059,7 +1827,7 @@ var FarcasterTestSuite = class {
       if (!result || result.length === 0) {
         throw new Error("Cast posting failed.");
       }
-      logger7.success("Successfully posted a test cast.");
+      logger10.success("Successfully posted a test cast.");
     } catch (error) {
       throw new Error(`Error posting a cast: ${error}`);
     }
@@ -1087,7 +1855,7 @@ var FarcasterTestSuite = class {
       if (!result || result.length === 0) {
         throw new Error("Cast with image posting failed.");
       }
-      logger7.success("Successfully posted a test cast with image.");
+      logger10.success("Successfully posted a test cast with image.");
     } catch (error) {
       throw new Error(`Error posting a cast with image: ${error}`);
     }
@@ -1115,15 +1883,15 @@ var FarcasterTestSuite = class {
         },
         timestamp: /* @__PURE__ */ new Date()
       };
-      const memoryId = createUniqueUuid3(runtime, testCast.hash);
+      const memoryId = createUniqueUuid6(runtime, testCast.hash);
       const memory = {
         id: memoryId,
         agentId: runtime.agentId,
         content: {
           text: testCast.text
         },
-        entityId: createUniqueUuid3(runtime, String(testCast.authorFid)),
-        roomId: createUniqueUuid3(runtime, "test-room"),
+        entityId: createUniqueUuid6(runtime, String(testCast.authorFid)),
+        roomId: createUniqueUuid6(runtime, "test-room"),
         createdAt: testCast.timestamp.getTime()
       };
       runtime.emitEvent("farcaster.mention_received", {
@@ -1132,7 +1900,7 @@ var FarcasterTestSuite = class {
         cast: testCast,
         source: "farcaster"
       });
-      logger7.success("Successfully simulated cast response handling");
+      logger10.success("Successfully simulated cast response handling");
     } catch (error) {
       throw new Error(`Error handling cast response: ${error}`);
     }
@@ -1146,18 +1914,313 @@ var FarcasterTestSuite = class {
    */
   async generateRandomCastContent(runtime, context = "general") {
     const prompt = `Generate a short, interesting cast about ${context} (max 280 chars).`;
-    const result = await runtime.useModel(ModelType2.TEXT_SMALL, {
+    const result = await runtime.useModel(ModelType3.TEXT_SMALL, {
       prompt
     });
     return result.substring(0, 280);
   }
+  /**
+   * Tests the MessageService functionality
+   *
+   * @param {IAgentRuntime} runtime - The runtime environment.
+   * @returns {Promise<void>} A promise that resolves when the test is complete.
+   */
+  async testMessageService(runtime) {
+    try {
+      const service = runtime.getService(FARCASTER_SERVICE_NAME);
+      if (!service) {
+        throw new Error("Farcaster service not found");
+      }
+      const messageService = service.getMessageService(runtime.agentId);
+      if (!messageService) {
+        throw new Error("MessageService not initialized");
+      }
+      const messages = await messageService.getMessages({
+        agentId: runtime.agentId,
+        limit: 5
+      });
+      logger10.log(`Retrieved ${messages.length} messages from MessageService`);
+      const testText = await this.generateRandomCastContent(runtime, "message_service_test");
+      const message = await messageService.sendMessage({
+        agentId: runtime.agentId,
+        roomId: createUniqueUuid6(runtime, "test-room"),
+        text: testText,
+        type: "CAST" /* CAST */
+      });
+      if (!message || !message.id) {
+        throw new Error("Failed to send message via MessageService");
+      }
+      logger10.success("MessageService test completed successfully");
+    } catch (error) {
+      throw new Error(`Error testing MessageService: ${error}`);
+    }
+  }
+  /**
+   * Tests the PostService functionality
+   *
+   * @param {IAgentRuntime} runtime - The runtime environment.
+   * @returns {Promise<void>} A promise that resolves when the test is complete.
+   */
+  async testPostService(runtime) {
+    try {
+      const service = runtime.getService(FARCASTER_SERVICE_NAME);
+      if (!service) {
+        throw new Error("Farcaster service not found");
+      }
+      const castService = service.getCastService(runtime.agentId);
+      if (!castService) {
+        throw new Error("CastService not initialized");
+      }
+      const casts = await castService.getCasts({
+        agentId: runtime.agentId,
+        limit: 5
+      });
+      logger10.log(`Retrieved ${casts.length} casts from CastService`);
+      const testText = await this.generateRandomCastContent(runtime, "cast_service_test");
+      const cast = await castService.createCast({
+        agentId: runtime.agentId,
+        roomId: createUniqueUuid6(runtime, "test-room"),
+        text: testText
+      });
+      if (!cast || !cast.id) {
+        throw new Error("Failed to create cast via CastService");
+      }
+      logger10.success("CastService test completed successfully");
+    } catch (error) {
+      throw new Error(`Error testing PostService: ${error}`);
+    }
+  }
+  /**
+   * Tests real account posting functionality
+   *
+   * @param {IAgentRuntime} runtime - The runtime environment.
+   * @returns {Promise<void>} A promise that resolves when the test is complete.
+   */
+  async testRealAccountPosting(runtime) {
+    var _a;
+    try {
+      const service = runtime.getService(FARCASTER_SERVICE_NAME);
+      if (!service) {
+        throw new Error("Farcaster service not found");
+      }
+      const postService = service.getPostService(runtime.agentId);
+      if (!postService) {
+        throw new Error("PostService not initialized");
+      }
+      const testPosts = [
+        "Testing ElizaOS Farcaster integration! \u{1F680} #ElizaOS",
+        "AI agents are the future of social media engagement \u{1F916}",
+        "Building amazing things with the ElizaOS framework \u{1F4BB}"
+      ];
+      for (const text of testPosts) {
+        const post = await postService.createPost({
+          agentId: runtime.agentId,
+          roomId: createUniqueUuid6(runtime, "real-test"),
+          text
+        });
+        if (!post || !post.id || !((_a = post.metadata) == null ? void 0 : _a.castHash)) {
+          throw new Error("Failed to create real post");
+        }
+        logger10.success(`Posted real cast: ${post.metadata.castHash}`);
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+      }
+      logger10.success("Real account posting test completed successfully");
+    } catch (error) {
+      throw new Error(`Error testing real account posting: ${error}`);
+    }
+  }
+  /**
+   * Tests real account interactions (mentions, replies, etc)
+   *
+   * @param {IAgentRuntime} runtime - The runtime environment.
+   * @returns {Promise<void>} A promise that resolves when the test is complete.
+   */
+  async testRealAccountInteractions(runtime) {
+    var _a, _b;
+    try {
+      const service = runtime.getService(FARCASTER_SERVICE_NAME);
+      if (!service) {
+        throw new Error("Farcaster service not found");
+      }
+      const postService = service.getPostService(runtime.agentId);
+      const messageService = service.getMessageService(runtime.agentId);
+      if (!postService || !messageService) {
+        throw new Error("Services not initialized");
+      }
+      const mentions = await postService.getMentions(runtime.agentId, { limit: 10 });
+      logger10.log(`Found ${mentions.length} mentions`);
+      const timeline = await postService.getPosts({
+        agentId: runtime.agentId,
+        limit: 20
+      });
+      logger10.log(`Found ${timeline.length} timeline posts`);
+      if (timeline.length > 0) {
+        const targetPost = timeline[0];
+        if ((_a = targetPost.metadata) == null ? void 0 : _a.castHash) {
+          const reply = await messageService.sendMessage({
+            agentId: runtime.agentId,
+            roomId: targetPost.roomId,
+            text: "Great post! Testing real interactions with ElizaOS \u{1F389}",
+            type: "REPLY" /* REPLY */,
+            replyToId: targetPost.metadata.castHash,
+            metadata: {
+              parentHash: targetPost.metadata.castHash
+            }
+          });
+          if (reply && ((_b = reply.metadata) == null ? void 0 : _b.castHash)) {
+            logger10.success(`Replied to cast with: ${reply.metadata.castHash}`);
+          }
+        }
+      }
+      logger10.success("Real account interactions test completed successfully");
+    } catch (error) {
+      throw new Error(`Error testing real account interactions: ${error}`);
+    }
+  }
+  /**
+   * Tests message metadata tracking functionality
+   *
+   * @param {IAgentRuntime} runtime - The runtime environment.
+   * @returns {Promise<void>} A promise that resolves when the test is complete.
+   */
+  async testMessageMetadataTracking(runtime) {
+    var _a, _b;
+    try {
+      const service = runtime.getService(FARCASTER_SERVICE_NAME);
+      if (!service) {
+        throw new Error("Farcaster service not found");
+      }
+      const messageService = service.getMessageService(runtime.agentId);
+      if (!messageService) {
+        throw new Error("MessageService not initialized");
+      }
+      const testMessage = await messageService.sendMessage({
+        agentId: runtime.agentId,
+        roomId: createUniqueUuid6(runtime, "metadata-test"),
+        text: "Testing metadata tracking with ElizaOS",
+        type: "CAST" /* CAST */
+      });
+      if (!testMessage || !((_a = testMessage.metadata) == null ? void 0 : _a.castHash)) {
+        throw new Error("Failed to send test message");
+      }
+      const castHash = testMessage.metadata.castHash;
+      logger10.log(`Sent message with cast hash: ${castHash}`);
+      const retrievedMessage = await messageService.getMessage(castHash, runtime.agentId);
+      if (!retrievedMessage) {
+        throw new Error("Failed to retrieve message by hash");
+      }
+      if (((_b = retrievedMessage.metadata) == null ? void 0 : _b.castHash) !== castHash) {
+        throw new Error("Metadata mismatch in retrieved message");
+      }
+      logger10.success("Message metadata tracking test completed successfully");
+    } catch (error) {
+      throw new Error(`Error testing message metadata tracking: ${error}`);
+    }
+  }
+};
+
+// src/actions/replyCast.ts
+import {
+  logger as logger11
+} from "@elizaos/core";
+var replyCastAction = {
+  name: "REPLY_TO_CAST",
+  description: "Replies to a cast on Farcaster",
+  examples: [
+    [
+      {
+        name: "user",
+        content: { text: "Someone asked about ElizaOS on Farcaster, can you reply?" }
+      },
+      {
+        name: "assistant",
+        content: {
+          text: "I'll reply to their question about ElizaOS.",
+          actions: ["REPLY_TO_CAST"]
+        }
+      }
+    ],
+    [
+      {
+        name: "user",
+        content: { text: "Reply to that cast and thank them for the feedback" }
+      },
+      {
+        name: "assistant",
+        content: {
+          text: "I'll reply with a thank you message.",
+          actions: ["REPLY_TO_CAST"]
+        }
+      }
+    ]
+  ],
+  validate: async (runtime, message) => {
+    var _a;
+    const text = ((_a = message.content.text) == null ? void 0 : _a.toLowerCase()) || "";
+    const keywords = ["reply", "respond", "answer", "comment"];
+    const hasKeyword = keywords.some((keyword) => text.includes(keyword));
+    const hasParentCast = !!(message.content.metadata && message.content.metadata.parentCastHash);
+    const service = runtime.getService(FARCASTER_SERVICE_NAME);
+    const isServiceAvailable = !!(service == null ? void 0 : service.getMessageService(runtime.agentId));
+    return hasKeyword && (hasParentCast || isServiceAvailable);
+  },
+  handler: async (runtime, message, state) => {
+    var _a;
+    try {
+      const service = runtime.getService(FARCASTER_SERVICE_NAME);
+      const messageService = service == null ? void 0 : service.getMessageService(runtime.agentId);
+      if (!messageService) {
+        logger11.error("[REPLY_TO_CAST] MessageService not available");
+        return false;
+      }
+      const parentCastHash = ((_a = message.content.metadata) == null ? void 0 : _a.parentCastHash) || (state == null ? void 0 : state.parentCastHash);
+      if (!parentCastHash) {
+        logger11.error("[REPLY_TO_CAST] No parent cast to reply to");
+        return false;
+      }
+      let replyContent = "";
+      if (state == null ? void 0 : state.replyContent) {
+        replyContent = state.replyContent;
+      } else {
+        const prompt = `Based on this request: "${message.content.text}", generate a helpful and engaging reply for a Farcaster cast (max 320 characters).`;
+        const response = await runtime.useModel("text_large", { prompt });
+        replyContent = typeof response === "string" ? response : response.text || "";
+      }
+      if (replyContent.length > 320) {
+        replyContent = replyContent.substring(0, 317) + "...";
+      }
+      const reply = await messageService.sendMessage({
+        agentId: runtime.agentId,
+        roomId: message.roomId,
+        text: replyContent,
+        type: "REPLY" /* REPLY */,
+        replyToId: parentCastHash,
+        metadata: {
+          parentHash: parentCastHash
+        }
+      });
+      logger11.info(`[REPLY_TO_CAST] Successfully replied to cast: ${reply.id}`);
+      return true;
+    } catch (error) {
+      logger11.error("[REPLY_TO_CAST] Error replying to cast:", error);
+      return false;
+    }
+  }
 };
 
+// src/actions/index.ts
+var farcasterActions = [sendCastAction, replyCastAction];
+
+// src/providers/index.ts
+var farcasterProviders = [farcasterProfileProvider, farcasterTimelineProvider];
+
 // src/index.ts
 var farcasterPlugin = {
   name: "farcaster",
-  description: "Farcaster client plugin",
+  description: "Farcaster client plugin for sending and receiving casts",
   services: [FarcasterService],
+  actions: farcasterActions,
+  providers: farcasterProviders,
   tests: [new FarcasterTestSuite()]
 };
 var index_default = farcasterPlugin;