@elizaos/plugin-farcaster 1.0.5 → 1.7.0

package/dist/index.js

@@ -1,37 +1,287 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/common/constants.ts
+var FARCASTER_SERVICE_NAME = "farcaster", FARCASTER_SOURCE = "farcaster", DEFAULT_MAX_CAST_LENGTH = 320, DEFAULT_POLL_INTERVAL = 120, DEFAULT_CAST_INTERVAL_MIN = 90, DEFAULT_CAST_INTERVAL_MAX = 180, DEFAULT_CAST_CACHE_TTL, DEFAULT_CAST_CACHE_SIZE = 9000;
+var init_constants = __esm(() => {
+  DEFAULT_CAST_CACHE_TTL = 1000 * 30 * 60;
+});
+
+// src/actions/sendCast.ts
+var exports_sendCast = {};
+__export(exports_sendCast, {
+  sendCastAction: () => sendCastAction
+});
 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";
+  logger as logger8,
+  createUniqueUuid as createUniqueUuid5
+} from "@elizaos/core";
+var sendCastAction;
+var init_sendCast = __esm(() => {
+  init_constants();
+  sendCastAction = {
+    name: "SEND_CAST",
+    description: "Posts a cast (message) on Farcaster",
+    examples: [
+      [
+        {
+          name: "user",
+          content: { text: "Can you post about the new ElizaOS features on Farcaster?" }
+        },
+        {
+          name: "assistant",
+          content: {
+            text: "I'll post about the new ElizaOS features on Farcaster now.",
+            actions: ["SEND_CAST"]
+          }
+        }
+      ],
+      [
+        {
+          name: "user",
+          content: { text: "Share on Farcaster that we just launched version 2.0!" }
+        },
+        {
+          name: "assistant",
+          content: {
+            text: "I'll share the version 2.0 launch announcement on Farcaster.",
+            actions: ["SEND_CAST"]
+          }
+        }
+      ]
+    ],
+    validate: async (runtime, message) => {
+      const text = message.content.text?.toLowerCase() || "";
+      const keywords = ["post", "cast", "share", "announce", "farcaster", "tweet"];
+      const hasKeyword = keywords.some((keyword) => text.includes(keyword));
+      const service = runtime.getService(FARCASTER_SERVICE_NAME);
+      const isServiceAvailable = !!service?.getCastService(runtime.agentId);
+      return hasKeyword && isServiceAvailable;
+    },
+    handler: async (runtime, message, state) => {
+      try {
+        const service = runtime.getService(FARCASTER_SERVICE_NAME);
+        const postService = service?.getCastService(runtime.agentId);
+        if (!postService) {
+          runtime.logger.error("[SEND_CAST] PostService not available");
+          return;
+        }
+        let castContent = "";
+        if (state?.castContent) {
+          castContent = state.castContent;
+        } else {
+          const prompt = `Based on this request: "${message.content.text}", generate a concise Farcaster cast (max 320 characters). Be engaging and use appropriate hashtags if relevant.`;
+          const response = await runtime.useModel("text_large", { prompt });
+          castContent = typeof response === "string" ? response : response.text || "";
+        }
+        if (castContent.length > 320) {
+          castContent = castContent.substring(0, 317) + "...";
+        }
+        const cast = await postService.createCast({
+          agentId: runtime.agentId,
+          roomId: createUniqueUuid5(runtime, "farcaster-timeline"),
+          text: castContent
+        });
+        logger8.info(`[SEND_CAST] Successfully posted cast: ${cast.id}`);
+        await runtime.createMemory({
+          agentId: runtime.agentId,
+          roomId: cast.roomId,
+          entityId: runtime.agentId,
+          content: {
+            text: castContent,
+            source: "farcaster",
+            metadata: {
+              castHash: cast.metadata?.castHash,
+              action: "SEND_CAST"
+            }
+          },
+          createdAt: cast.timestamp
+        }, "messages");
+      } catch (error) {
+        runtime.logger.error("[SEND_CAST] Error posting cast:", typeof error === "string" ? error : error.message);
+        throw error;
+      }
+    }
+  };
+});
+
+// src/providers/profileProvider.ts
+var exports_profileProvider = {};
+__export(exports_profileProvider, {
+  farcasterProfileProvider: () => farcasterProfileProvider
+});
+var farcasterProfileProvider;
+var init_profileProvider = __esm(() => {
+  init_constants();
+  farcasterProfileProvider = {
+    name: "farcasterProfile",
+    description: "Provides information about the agent's Farcaster profile",
+    get: async (runtime, message, state) => {
+      try {
+        const service = runtime.getService(FARCASTER_SERVICE_NAME);
+        const managers = service?.getActiveManagers();
+        if (!managers || managers.size === 0) {
+          runtime.logger.debug("[FarcasterProfileProvider] No managers available");
+          return {
+            text: "Farcaster profile not available.",
+            data: { available: false }
+          };
+        }
+        const manager = managers.get(runtime.agentId);
+        if (!manager) {
+          runtime.logger.debug("[FarcasterProfileProvider] No manager for this agent");
+          return {
+            text: "Farcaster profile not available for this agent.",
+            data: { available: false }
+          };
+        }
+        const fid = parseInt(runtime.getSetting("FARCASTER_FID"), 10);
+        if (!fid || isNaN(fid)) {
+          runtime.logger.warn("[FarcasterProfileProvider] Invalid or missing FARCASTER_FID");
+          return {
+            text: "Invalid Farcaster FID configured.",
+            data: { available: false, error: "Invalid FID" }
+          };
+        }
+        try {
+          const profile = await manager.client.getProfile(fid);
+          return {
+            text: `Your Farcaster profile: @${profile.username} (FID: ${profile.fid}). ${profile.name ? `Display name: ${profile.name}` : ""}`,
+            data: {
+              available: true,
+              fid: profile.fid,
+              username: profile.username,
+              name: profile.name,
+              pfp: profile.pfp
+            },
+            values: {
+              fid: profile.fid,
+              username: profile.username
+            }
+          };
+        } catch (error) {
+          runtime.logger.error("[FarcasterProfileProvider] Error fetching profile:", typeof error === "string" ? error : error.message);
+          return {
+            text: "Unable to fetch Farcaster profile at this time.",
+            data: { available: false, error: "Fetch failed" }
+          };
+        }
+      } catch (error) {
+        runtime.logger.error("[FarcasterProfileProvider] Error:", typeof error === "string" ? error : error.message);
+        return {
+          text: "Farcaster service is not available.",
+          data: { available: false }
+        };
+      }
+    }
+  };
+});
+
+// src/providers/timelineProvider.ts
+var exports_timelineProvider = {};
+__export(exports_timelineProvider, {
+  farcasterTimelineProvider: () => farcasterTimelineProvider
+});
+function getTimeAgo(date) {
+  const seconds = Math.floor((new Date().getTime() - date.getTime()) / 1000);
+  if (seconds < 60)
+    return "just now";
+  if (seconds < 3600)
+    return `${Math.floor(seconds / 60)}m ago`;
+  if (seconds < 86400)
+    return `${Math.floor(seconds / 3600)}h ago`;
+  return `${Math.floor(seconds / 86400)}d ago`;
+}
+var farcasterTimelineProvider;
+var init_timelineProvider = __esm(() => {
+  init_constants();
+  farcasterTimelineProvider = {
+    name: "farcasterTimeline",
+    description: "Provides recent casts from the agent's Farcaster timeline",
+    get: async (runtime, message, state) => {
+      try {
+        const service = runtime.getService(FARCASTER_SERVICE_NAME);
+        const castService = service?.getCastService(runtime.agentId);
+        if (!castService) {
+          return {
+            text: "Farcaster timeline not available.",
+            data: { available: false }
+          };
+        }
+        const casts = await castService.getCasts({
+          agentId: runtime.agentId,
+          limit: 5
+        });
+        if (!casts || casts.length === 0) {
+          return {
+            text: "No recent casts in your timeline.",
+            data: {
+              available: true,
+              casts: [],
+              count: 0
+            }
+          };
+        }
+        const formattedCasts = casts.map((cast, index) => {
+          const timeAgo = getTimeAgo(new Date(cast.timestamp));
+          return `${index + 1}. @${cast.username} (${timeAgo}): ${cast.text}`;
+        }).join(`
+`);
+        return {
+          text: `Recent casts from your timeline:
+${formattedCasts}`,
+          data: {
+            available: true,
+            casts: casts.map((c) => ({
+              id: c.id,
+              username: c.username,
+              text: c.text,
+              timestamp: c.timestamp,
+              castHash: c.metadata?.castHash
+            })),
+            count: casts.length
+          },
+          values: {
+            latestCastHash: casts[0]?.metadata?.castHash,
+            latestCastText: casts[0]?.text
+          }
+        };
+      } catch (error) {
+        runtime.logger.error("[FarcasterTimelineProvider] Error:", typeof error === "string" ? error : error.message);
+        return {
+          text: "Unable to fetch Farcaster timeline.",
+          data: { available: false, error: error instanceof Error ? error.message : "Unknown error" }
+        };
+      }
+    }
+  };
+});
 
 // src/service.ts
-import { logger as logger8, Service } from "@elizaos/core";
+init_constants();
+import { logger as logger7, Service } from "@elizaos/core";
 
 // src/managers/agent.ts
 import { logger as logger4 } from "@elizaos/core";
 import { Configuration, NeynarAPIClient } from "@neynar/nodejs-sdk";
 
 // src/client.ts
+init_constants();
 import { elizaLogger } from "@elizaos/core";
 import { isApiErrorResponse } from "@neynar/nodejs-sdk";
-import { CastParamType } from "@neynar/nodejs-sdk/build/api/index.js";
 import { LRUCache } from "lru-cache";
 
 // src/common/utils.ts
+init_constants();
 import { stringToUuid } from "@elizaos/core";
 var MAX_CAST_LENGTH = 1024;
 function castId({ hash, agentId }) {
@@ -41,14 +291,21 @@ function castUuid(props) {
   return stringToUuid(castId(props));
 }
 function splitPostContent(content, maxLength = MAX_CAST_LENGTH) {
-  const paragraphs = content.split("\n\n").map((p) => p.trim());
+  const paragraphs = content.split(`
+
+`).map((p) => p.trim());
   const posts = [];
   let currentCast = "";
   for (const paragraph of paragraphs) {
-    if (!paragraph) continue;
-    if ((currentCast + "\n\n" + paragraph).trim().length <= maxLength) {
+    if (!paragraph)
+      continue;
+    if ((currentCast + `
+
+` + paragraph).trim().length <= maxLength) {
       if (currentCast) {
-        currentCast += "\n\n" + paragraph;
+        currentCast += `
+
+` + paragraph;
       } else {
         currentCast = paragraph;
       }
@@ -116,18 +373,17 @@ function lastCastCacheKey(fid) {
   return `farcaster/${fid}/lastCast`;
 }
 function neynarCastToCast(neynarCast) {
-  var _a;
   return {
     hash: neynarCast.hash,
     authorFid: neynarCast.author.fid,
     text: neynarCast.text,
-    threadId: neynarCast.thread_hash ?? void 0,
+    threadId: neynarCast.thread_hash ?? undefined,
     profile: {
       fid: neynarCast.author.fid,
       name: neynarCast.author.display_name || "anon",
       username: neynarCast.author.username
     },
-    ...neynarCast.parent_hash && ((_a = neynarCast.parent_author) == null ? void 0 : _a.fid) ? {
+    ...neynarCast.parent_hash && neynarCast.parent_author?.fid ? {
       inReplyTo: {
         hash: neynarCast.parent_hash,
         fid: neynarCast.parent_author.fid
@@ -145,7 +401,7 @@ function createCastMemory({
   const inReplyTo = cast.inReplyTo ? castUuid({
     hash: cast.inReplyTo.hash,
     agentId: runtime.agentId
-  }) : void 0;
+  }) : undefined;
   return {
     id: castUuid({
       hash: cast.hash,
@@ -164,14 +420,6 @@ function createCastMemory({
     roomId
   };
 }
-function formatCastTimestamp(timestamp) {
-  return timestamp.toLocaleString("en-US", {
-    hour: "2-digit",
-    minute: "2-digit",
-    month: "short",
-    day: "numeric"
-  });
-}
 
 // src/client.ts
 var castCache = new LRUCache({
@@ -179,11 +427,11 @@ var castCache = new LRUCache({
   ttl: DEFAULT_CAST_CACHE_TTL
 });
 var profileCache = new LRUCache({
-  max: 1e3,
-  ttl: 1e3 * 60 * 15
-  // 15 minutes
+  max: 1000,
+  ttl: 1000 * 60 * 15
 });
-var FarcasterClient = class {
+
+class FarcasterClient {
   neynar;
   signerUuid;
   constructor(opts) {
@@ -211,7 +459,7 @@ var FarcasterClient = class {
       const result = await this.neynar.publishCast({
         signerUuid: this.signerUuid,
         text: cast,
-        parent: parentCastId == null ? void 0 : parentCastId.hash
+        parent: parentCastId?.hash
       });
       if (result.success) {
         return this.getCast(result.cast.hash);
@@ -219,10 +467,10 @@ var FarcasterClient = class {
       throw new Error(`[Farcaster] Error publishing [${cast}] parentCastId: [${parentCastId}]`);
     } catch (err) {
       if (isApiErrorResponse(err)) {
-        elizaLogger.error("Neynar error: ", err.response.data);
+        elizaLogger.error(`Neynar error: ${JSON.stringify(err.response.data)}`);
         throw err.response.data;
       } else {
-        elizaLogger.error("Error: ", err);
+        elizaLogger.error(`Error: ${JSON.stringify(err)}`);
         throw err;
       }
     }
@@ -232,8 +480,7 @@ var FarcasterClient = class {
     if (cachedCast) {
       return cachedCast;
     }
-    const params = { identifier: castHash, type: CastParamType.Hash };
-    const response = await this.neynar.lookupCastByHashOrWarpcastUrl(params);
+    const response = await this.neynar.lookupCastByHashOrUrl({ identifier: castHash, type: "hash" });
     castCache.set(castHash, response.cast);
     return response.cast;
   }
@@ -275,12 +522,11 @@ var FarcasterClient = class {
       profileCache.set(fid, profile);
       return profile;
     } catch (error) {
-      elizaLogger.error("Error fetching profile:", error);
+      elizaLogger.error(`Error fetching profile: ${JSON.stringify(error)}`);
       throw error;
     }
   }
   async getTimeline(request) {
-    var _a;
     const timeline = [];
     const response = await this.neynar.fetchCastsForUser({
       fid: request.fid,
@@ -290,7 +536,7 @@ var FarcasterClient = class {
       castCache.set(cast.hash, cast);
       timeline.push(neynarCastToCast(cast));
     }
-    const nextCursor = ((_a = response.next) == null ? void 0 : _a.cursor) ?? void 0;
+    const nextCursor = response.next?.cursor ?? undefined;
     return {
       timeline,
       cursor: nextCursor
@@ -300,78 +546,10 @@ var FarcasterClient = class {
     profileCache.clear();
     castCache.clear();
   }
-};
-
-// src/managers/interactions.ts
-import {
-  ChannelType,
-  composePrompt,
-  createUniqueUuid,
-  EventType,
-  logger as logger2,
-  ModelType
-} from "@elizaos/core";
+}
 
-// src/common/asyncqueue.ts
-var AsyncQueue = class {
-  queue = [];
-  running = 0;
-  emptyListeners = [];
-  maxConcurrent;
-  constructor(maxConcurrent = 1) {
-    this.maxConcurrent = maxConcurrent;
-  }
-  async submit(work) {
-    return new Promise((resolve, reject) => {
-      this.queue.push(async () => {
-        try {
-          resolve(await work());
-        } catch (err) {
-          reject(err);
-        }
-      });
-      void this.doNextWork();
-    });
-  }
-  async doNextWork() {
-    if (this.running >= this.maxConcurrent) {
-      return;
-    }
-    const work = this.queue.shift();
-    if (!work) {
-      this.checkIfEmptyAndNotify();
-      return;
-    }
-    this.running++;
-    try {
-      await work();
-    } catch (err) {
-    } finally {
-      this.running--;
-      void this.doNextWork();
-    }
-  }
-  async size() {
-    return this.queue.length;
-  }
-  async waitUntilFinished() {
-    return new Promise((resolve) => {
-      if (this.queue.length === 0 && this.running === 0) {
-        resolve();
-      } else {
-        this.emptyListeners.push(resolve);
-      }
-    });
-  }
-  checkIfEmptyAndNotify() {
-    if (this.queue.length === 0 && this.running === 0) {
-      while (this.emptyListeners.length) {
-        const listener = this.emptyListeners.shift();
-        if (listener) listener();
-      }
-    }
-  }
-};
+// src/managers/post.ts
+import { createUniqueUuid, EventType } from "@elizaos/core";
 
 // src/common/callbacks.ts
 import { logger } from "@elizaos/core";
@@ -396,7 +574,7 @@ function standardCastHandlerCallback({
         return [];
       }
       const memories = [];
-      for (let i = 0; i < casts.length; i++) {
+      for (let i = 0;i < casts.length; i++) {
         const cast = casts[i];
         logger.success(`[Farcaster] Published cast ${cast.hash}`);
         const memory = createCastMemory({
@@ -416,7 +594,7 @@ function standardCastHandlerCallback({
       }
       return memories;
     } catch (error) {
-      logger.error("[Farcaster] Error posting cast:", error);
+      runtime.logger.error("[Farcaster] Error posting cast:", typeof error === "string" ? error : error.message);
       if (onError) {
         await onError(error);
       }
@@ -426,27 +604,18 @@ function standardCastHandlerCallback({
   return callback;
 }
 
-// src/common/prompts.ts
-var formatCast = (cast) => {
-  return `ID: ${cast.hash}
-    From: ${cast.profile.name} (@${cast.profile.username})${cast.profile.username})${cast.inReplyTo ? `
-In reply to: ${cast.inReplyTo.fid}` : ""}
-Text: ${cast.text}`;
-};
-var formatTimeline = (character, timeline) => `# ${character.name}'s Home Timeline
-${timeline.map(formatCast).join("\n")}
-`;
-
-// src/managers/interactions.ts
-import { shouldRespondTemplate } from "@elizaos/core";
+// src/managers/post.ts
+init_constants();
 
 // src/common/types.ts
+init_constants();
 import { z } from "zod";
 var FarcasterConfigSchema = z.object({
   FARCASTER_DRY_RUN: z.union([z.boolean(), z.string()]).transform((val) => typeof val === "string" ? val.toLowerCase() === "true" : val),
   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),
+  FARCASTER_MODE: z.enum(["polling", "webhook"]).default("polling"),
   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(),
@@ -459,52 +628,356 @@ var FarcasterConfigSchema = z.object({
   FARCASTER_HUB_URL: z.string().min(1, "FARCASTER_HUB_URL is not set")
 });
 
-// src/managers/interactions.ts
-var FarcasterInteractionManager = class {
-  timeout;
-  isRunning = false;
+// src/managers/post.ts
+class FarcasterCastManager {
   client;
   runtime;
+  fid;
+  timeout;
   config;
-  asyncQueue;
+  isRunning = false;
   constructor(opts) {
     this.client = opts.client;
     this.runtime = opts.runtime;
     this.config = opts.config;
-    this.asyncQueue = new AsyncQueue(1);
+    this.fid = this.config.FARCASTER_FID;
+  }
+  async start() {
+    if (this.isRunning || !this.config.ENABLE_CAST) {
+      return;
+    }
+    this.isRunning = true;
+    this.runPeriodically();
+  }
+  async stop() {
+    if (this.timeout)
+      clearTimeout(this.timeout);
+    this.isRunning = false;
+  }
+  calculateDelay() {
+    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 * 1000;
+    return { delay, randomMinutes };
+  }
+  async runPeriodically() {
+    if (this.config.CAST_IMMEDIATELY) {
+      await this.generateNewCast();
+    }
+    while (this.isRunning) {
+      try {
+        const lastPost = await this.runtime.getCache(lastCastCacheKey(this.fid));
+        const lastPostTimestamp = lastPost?.timestamp ?? 0;
+        const { delay, randomMinutes } = this.calculateDelay();
+        if (Date.now() > lastPostTimestamp + delay) {
+          await this.generateNewCast();
+        }
+        this.runtime.logger.log(`Next cast scheduled in ${randomMinutes} minutes`);
+        await new Promise((resolve) => this.timeout = setTimeout(resolve, delay));
+      } catch (error) {
+        this.runtime.logger.error({ agentId: this.runtime.agentId, error }, "[Farcaster] Error in periodic cast loop:");
+      }
+    }
+  }
+  async generateNewCast() {
+    this.runtime.logger.info("Generating new cast");
+    try {
+      const worldId = createUniqueUuid(this.runtime, this.fid.toString());
+      const roomId = createUniqueUuid(this.runtime, `${this.fid}-home`);
+      const callback = standardCastHandlerCallback({
+        client: this.client,
+        runtime: this.runtime,
+        config: this.config,
+        roomId,
+        onCompletion: async (casts, _memories) => {
+          const lastCast = casts[casts.length - 1];
+          await this.runtime.setCache(lastCastCacheKey(this.fid), {
+            hash: lastCast.hash,
+            timestamp: new Date(lastCast.timestamp).getTime()
+          });
+        }
+      });
+      this.runtime.emitEvent([EventType.POST_GENERATED, "FARCASTER_CAST_GENERATED" /* CAST_GENERATED */], {
+        runtime: this.runtime,
+        callback,
+        worldId,
+        userId: this.runtime.agentId,
+        roomId,
+        source: FARCASTER_SOURCE
+      });
+    } catch (error) {
+      this.runtime.logger.error({ error }, "[Farcaster] Error generating new cast");
+    }
+  }
+}
+
+// src/managers/interactions.ts
+import {
+  ChannelType,
+  createUniqueUuid as createUniqueUuid2,
+  logger as logger3,
+  stringToUuid as stringToUuid2
+} from "@elizaos/core";
+
+// src/common/asyncqueue.ts
+class AsyncQueue {
+  queue = [];
+  running = 0;
+  emptyListeners = [];
+  maxConcurrent;
+  constructor(maxConcurrent = 1) {
+    this.maxConcurrent = maxConcurrent;
+  }
+  async submit(work) {
+    return new Promise((resolve, reject) => {
+      this.queue.push(async () => {
+        try {
+          resolve(await work());
+        } catch (err) {
+          reject(err);
+        }
+      });
+      this.doNextWork();
+    });
+  }
+  async doNextWork() {
+    if (this.running >= this.maxConcurrent) {
+      return;
+    }
+    const work = this.queue.shift();
+    if (!work) {
+      this.checkIfEmptyAndNotify();
+      return;
+    }
+    this.running++;
+    try {
+      await work();
+    } catch (err) {} finally {
+      this.running--;
+      this.doNextWork();
+    }
+  }
+  async size() {
+    return this.queue.length;
   }
+  async waitUntilFinished() {
+    return new Promise((resolve) => {
+      if (this.queue.length === 0 && this.running === 0) {
+        resolve();
+      } else {
+        this.emptyListeners.push(resolve);
+      }
+    });
+  }
+  checkIfEmptyAndNotify() {
+    if (this.queue.length === 0 && this.running === 0) {
+      while (this.emptyListeners.length) {
+        const listener = this.emptyListeners.shift();
+        if (listener)
+          listener();
+      }
+    }
+  }
+}
+
+// src/managers/interactions.ts
+init_constants();
+
+// src/managers/interaction-source.ts
+import { logger as logger2 } from "@elizaos/core";
+class FarcasterInteractionSource {
+  client;
+  runtime;
+  config;
+  processor;
+  isRunning = false;
+  constructor(params) {
+    this.client = params.client;
+    this.runtime = params.runtime;
+    this.config = params.config;
+    this.processor = params.processor;
+  }
+}
+
+class FarcasterPollingSource extends FarcasterInteractionSource {
+  timeout;
   async start() {
-    logger2.info("Starting Farcaster interactions");
+    logger2.info("Starting Farcaster polling mode");
     if (this.isRunning) {
       return;
     }
     this.isRunning = true;
-    void this.runPeriodically();
+    this.runPeriodically();
   }
   async stop() {
-    if (this.timeout) clearTimeout(this.timeout);
+    logger2.info("Stopping Farcaster polling mode");
+    if (this.timeout)
+      clearTimeout(this.timeout);
     this.isRunning = false;
   }
   async runPeriodically() {
     while (this.isRunning) {
       try {
-        await this.handleInteractions();
-        const delay = this.config.FARCASTER_POLL_INTERVAL * 1e3;
-        await new Promise((resolve) => this.timeout = setTimeout(resolve, delay));
+        await this.pollForInteractions();
+        const delay = this.config.FARCASTER_POLL_INTERVAL * 1000;
+        await new Promise((resolve) => this.timeout = setTimeout(resolve, delay));
+      } catch (error) {
+        this.runtime.logger.error({ error }, "[Farcaster] Error in polling:");
+      }
+    }
+  }
+  async pollForInteractions() {
+    const agentFid = this.config.FARCASTER_FID;
+    const mentions = await this.client.getMentions({
+      fid: agentFid,
+      pageSize: 20
+    });
+    for (const cast of mentions) {
+      try {
+        const mention = neynarCastToCast(cast);
+        const memoryId = castUuid({ agentId: this.runtime.agentId, hash: mention.hash });
+        if (await this.runtime.getMemoryById(memoryId)) {
+          continue;
+        }
+        this.runtime.logger.info({ hash: mention.hash }, "New Cast found");
+        if (mention.authorFid === agentFid) {
+          const memory = await this.processor.ensureCastConnection(mention);
+          await this.runtime.addEmbeddingToMemory(memory);
+          await this.runtime.createMemory(memory, "messages");
+          continue;
+        }
+        await this.processor.processMention(cast);
+      } catch (error) {
+        this.runtime.logger.error({ error }, "[Farcaster] Error processing mention:");
+      }
+    }
+  }
+}
+
+class FarcasterWebhookSource extends FarcasterInteractionSource {
+  async start() {
+    logger2.info("Starting Farcaster webhook mode");
+    if (this.isRunning) {
+      return;
+    }
+    this.isRunning = true;
+    logger2.info("Webhook source is active - waiting for webhook events");
+  }
+  async stop() {
+    logger2.info("Stopping Farcaster webhook mode");
+    this.isRunning = false;
+  }
+  async processWebhookData(webhookData) {
+    if (!this.isRunning) {
+      logger2.warn("Webhook source is not running, ignoring webhook data");
+      return;
+    }
+    try {
+      await this.processor.processWebhookData(webhookData);
+    } catch (error) {
+      this.runtime.logger.error({ error }, "[Farcaster] Error processing webhook data:");
+    }
+  }
+}
+function createFarcasterInteractionSource(params) {
+  const mode = params.config.FARCASTER_MODE;
+  switch (mode) {
+    case "webhook":
+      return new FarcasterWebhookSource(params);
+    case "polling":
+    default:
+      return new FarcasterPollingSource(params);
+  }
+}
+
+// src/managers/interactions.ts
+class FarcasterInteractionManager {
+  client;
+  runtime;
+  config;
+  asyncQueue;
+  mode;
+  source;
+  constructor(opts) {
+    this.client = opts.client;
+    this.runtime = opts.runtime;
+    this.config = opts.config;
+    this.asyncQueue = new AsyncQueue(1);
+    this.mode = opts.config.FARCASTER_MODE;
+    this.source = createFarcasterInteractionSource({
+      client: this.client,
+      runtime: this.runtime,
+      config: this.config,
+      processor: this
+    });
+    logger3.info(`Farcaster interaction mode: ${this.mode}`);
+  }
+  async processMention(cast) {
+    const agentFid = this.config.FARCASTER_FID;
+    const agent = await this.client.getProfile(agentFid);
+    const mention = neynarCastToCast(cast);
+    await this.handleMentionCast({ agent, mention, cast });
+  }
+  async processReply(cast) {
+    const agentFid = this.config.FARCASTER_FID;
+    const agent = await this.client.getProfile(agentFid);
+    const reply = neynarCastToCast(cast);
+    await this.handleMentionCast({ agent, mention: reply, cast });
+  }
+  async processWebhookData(webhookData) {
+    if (webhookData.type !== "cast.created" || !webhookData.data) {
+      logger3.debug("Ignoring non-cast webhook event:", webhookData.type);
+      return;
+    }
+    const castData = webhookData.data;
+    const agentFid = this.config.FARCASTER_FID;
+    if (!castData.author || !castData.hash || typeof castData.author.fid !== "number") {
+      logger3.warn("Invalid webhook cast data structure - missing author, hash, or author.fid");
+      return;
+    }
+    if (castData.author.fid === agentFid) {
+      logger3.debug("Skipping webhook event from agent itself");
+      return;
+    }
+    const memoryId = castUuid({ agentId: this.runtime.agentId, hash: castData.hash });
+    if (await this.runtime.getMemoryById(memoryId)) {
+      logger3.debug("Skipping already processed webhook cast:", castData.hash);
+      return;
+    }
+    const isMention = castData.mentioned_profiles?.some((profile) => profile.fid === agentFid);
+    const isReply = castData.parent_hash && castData.parent_author?.fid === agentFid;
+    if (isMention) {
+      const username = castData.author.username || "unknown";
+      const text = castData.text || "";
+      logger3.info(`Processing webhook MENTION from @${username}: "${text}"`);
+      try {
+        const neynarCast = await this.client.getCast(castData.hash);
+        await this.processMention(neynarCast);
+      } catch (error) {
+        logger3.error({ agentId: this.runtime.agentId, error }, "Failed to process webhook mention from @" + username);
+      }
+    } else if (isReply) {
+      const username = castData.author.username || "unknown";
+      const text = castData.text || "";
+      logger3.info(`Processing webhook REPLY from @${username}: "${text}"`);
+      try {
+        const neynarCast = await this.client.getCast(castData.hash);
+        await this.processReply(neynarCast);
       } catch (error) {
-        logger2.error("[Farcaster] Error in periodic interactions:", this.runtime.agentId, error);
+        this.runtime.logger.error({ error }, `Failed to process webhook reply from @${username}:`);
       }
+    } else {
+      logger3.debug("Webhook cast is neither mention nor reply to agent");
     }
   }
   async ensureCastConnection(cast) {
     return await this.asyncQueue.submit(async () => {
-      var _a, _b;
       const memoryId = castUuid({ agentId: this.runtime.agentId, hash: cast.hash });
-      const conversationId = cast.threadId ?? ((_a = cast.inReplyTo) == null ? void 0 : _a.hash) ?? cast.hash;
-      const entityId = createUniqueUuid(this.runtime, cast.authorFid.toString());
-      const worldId = createUniqueUuid(this.runtime, cast.authorFid.toString());
-      const serverId = cast.authorFid.toString();
-      const roomId = createUniqueUuid(this.runtime, conversationId);
+      const conversationId = cast.threadId ?? cast.inReplyTo?.hash ?? cast.hash;
+      const entityId = createUniqueUuid2(this.runtime, cast.authorFid.toString());
+      const worldId = createUniqueUuid2(this.runtime, cast.authorFid.toString());
+      const roomId = createUniqueUuid2(this.runtime, conversationId);
       if (entityId !== this.runtime.agentId) {
         await this.runtime.ensureConnection({
           entityId,
@@ -515,7 +988,7 @@ var FarcasterInteractionManager = class {
           source: FARCASTER_SOURCE,
           type: ChannelType.THREAD,
           channelId: conversationId,
-          serverId,
+          messageServerId: stringToUuid2(cast.authorFid.toString()),
           worldId,
           metadata: {
             ownership: { ownerId: cast.authorFid.toString() },
@@ -532,8 +1005,7 @@ var FarcasterInteractionManager = class {
         agentId: this.runtime.agentId,
         content: {
           text: cast.text,
-          // need to pull imageUrls
-          inReplyTo: ((_b = cast.inReplyTo) == null ? void 0 : _b.hash) ? castUuid({ agentId: this.runtime.agentId, hash: cast.inReplyTo.hash }) : void 0,
+          inReplyTo: cast.inReplyTo?.hash ? castUuid({ agentId: this.runtime.agentId, hash: cast.inReplyTo.hash }) : undefined,
           source: FARCASTER_SOURCE,
           channelType: ChannelType.THREAD
         },
@@ -544,34 +1016,9 @@ var FarcasterInteractionManager = class {
       return memory;
     });
   }
-  async handleInteractions() {
-    const agentFid = this.config.FARCASTER_FID;
-    const [mentions, agent] = await Promise.all([
-      this.client.getMentions({
-        fid: agentFid,
-        pageSize: 20
-      }),
-      this.client.getProfile(agentFid)
-    ]);
-    for (const cast of mentions) {
-      const mention = neynarCastToCast(cast);
-      const memoryId = castUuid({ agentId: this.runtime.agentId, hash: mention.hash });
-      if (await this.runtime.getMemoryById(memoryId)) {
-        continue;
-      }
-      logger2.info("New Cast found", mention.hash);
-      if (mention.authorFid === agentFid) {
-        const memory = await this.ensureCastConnection(mention);
-        await this.runtime.addEmbeddingToMemory(memory);
-        await this.runtime.createMemory(memory, "messages");
-        continue;
-      }
-      await this.handleMentionCast({ agent, mention, cast });
-    }
-  }
   async buildThreadForCast(cast, skipMemoryId) {
     const thread = [];
-    const visited = /* @__PURE__ */ new Set();
+    const visited = new Set;
     const client = this.client;
     const runtime = this.runtime;
     const self = this;
@@ -583,12 +1030,12 @@ var FarcasterInteractionManager = class {
       visited.add(currentCast.hash);
       const memory = await runtime.getMemoryById(memoryId);
       if (!memory) {
-        logger2.info("Creating memory for cast", currentCast.hash);
-        const memory2 = await self.ensureCastConnection(currentCast);
-        await runtime.createMemory(memory2, "messages");
+        logger3.info({ hash: currentCast.hash }, "Creating memory for cast");
+        const newMemory = await self.ensureCastConnection(currentCast);
+        await runtime.createMemory(newMemory, "messages");
         runtime.emitEvent("FARCASTER_THREAD_CAST_CREATED" /* THREAD_CAST_CREATED */, {
           runtime,
-          memory: memory2,
+          memory: newMemory,
           cast: currentCast,
           source: FARCASTER_SOURCE
         });
@@ -607,51 +1054,14 @@ var FarcasterInteractionManager = class {
     mention,
     cast
   }) {
-    var _a, _b, _c;
     if (mention.profile.fid === agent.fid) {
-      logger2.info("skipping cast from bot itself", mention.hash);
+      logger3.info({ hash: mention.hash }, "skipping cast from bot itself");
       return;
     }
     const memory = await this.ensureCastConnection(mention);
-    const thread = await this.buildThreadForCast(
-      mention,
-      memory.id ? /* @__PURE__ */ new Set([memory.id]) : /* @__PURE__ */ new Set()
-    );
+    const thread = await this.buildThreadForCast(mention, memory.id ? new Set([memory.id]) : new Set);
     if (!memory.content.text || memory.content.text.trim() === "") {
-      logger2.info("skipping cast with no text", mention.hash);
-      return;
-    }
-    const currentPost = formatCast(mention);
-    const { timeline } = await this.client.getTimeline({ fid: agent.fid, pageSize: 20 });
-    const formattedTimeline = formatTimeline(this.runtime.character, timeline);
-    const formattedConversation = thread.map(
-      (c) => `
-        - @${c.profile.username} (${formatCastTimestamp(c.timestamp)}):
-          ${c.text}`.trim()
-    ).join("\n\n");
-    const state = await this.runtime.composeState(memory);
-    state.values = {
-      ...state.values,
-      farcasterUsername: agent.username,
-      timeline: formattedTimeline,
-      currentPost,
-      formattedConversation
-    };
-    const shouldRespondPrompt = composePrompt({
-      state,
-      template: ((_a = this.runtime.character.templates) == null ? void 0 : _a.farcasterShouldRespondTemplate) || ((_c = (_b = this.runtime.character) == null ? void 0 : _b.templates) == null ? void 0 : _c.shouldRespondTemplate) || shouldRespondTemplate
-    });
-    const response = await this.runtime.useModel(ModelType.TEXT_SMALL, {
-      prompt: shouldRespondPrompt
-    });
-    const responseActions = (response.match(/(?:RESPOND|IGNORE|STOP)/g) || ["IGNORE"])[0];
-    if (responseActions !== "RESPOND") {
-      logger2.info(`Not responding to cast based on shouldRespond decision: ${responseActions}`);
-      try {
-        await this.runtime.createMemory(memory, "messages");
-      } catch (error) {
-        logger2.error("Error creating ignoredmemory", error);
-      }
+      logger3.info({ hash: mention.hash }, "skipping cast with no text");
       return;
     }
     const callback = standardCastHandlerCallback({
@@ -664,113 +1074,39 @@ var FarcasterInteractionManager = class {
         fid: mention.authorFid
       }
     });
-    const messageReceivedPayload = {
-      runtime: this.runtime,
-      message: memory,
-      source: FARCASTER_SOURCE,
-      callback
-    };
-    this.runtime.emitEvent(EventType.MESSAGE_RECEIVED, messageReceivedPayload);
+    try {
+      if (!this.runtime.messageService) {
+        logger3.warn("[Farcaster] messageService not available, skipping mention handling");
+        return;
+      }
+      await this.runtime.messageService.handleMessage(this.runtime, memory, callback);
+    } catch (error) {
+      logger3.error({
+        error: error instanceof Error ? error.message : String(error),
+        castHash: mention.hash
+      }, "[Farcaster] Error processing mention");
+    }
     const mentionPayload = {
       runtime: this.runtime,
       memory,
       cast,
       source: FARCASTER_SOURCE,
-      callback: async (ontent, _files) => {
-        logger2.info("[Farcaster] mention received response:", response);
-        return [];
-      }
+      callback
     };
     this.runtime.emitEvent("FARCASTER_MENTION_RECEIVED" /* MENTION_RECEIVED */, mentionPayload);
   }
-};
-
-// src/managers/post.ts
-import { createUniqueUuid as createUniqueUuid2, EventType as EventType2, logger as logger3 } from "@elizaos/core";
-var FarcasterCastManager = class {
-  client;
-  runtime;
-  fid;
-  timeout;
-  config;
-  isRunning = false;
-  constructor(opts) {
-    this.client = opts.client;
-    this.runtime = opts.runtime;
-    this.config = opts.config;
-    this.fid = this.config.FARCASTER_FID;
-  }
   async start() {
-    if (this.isRunning || !this.config.ENABLE_CAST) {
-      return;
-    }
-    this.isRunning = true;
-    void this.runPeriodically();
+    logger3.info(`Starting Farcaster interaction manager in ${this.mode} mode`);
+    await this.source.start();
   }
   async stop() {
-    if (this.timeout) clearTimeout(this.timeout);
-    this.isRunning = false;
-  }
-  calculateDelay() {
-    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.CAST_IMMEDIATELY) {
-      await this.generateNewCast();
-    }
-    while (this.isRunning) {
-      try {
-        const lastPost = await this.runtime.getCache(lastCastCacheKey(this.fid));
-        const lastPostTimestamp = (lastPost == null ? void 0 : lastPost.timestamp) ?? 0;
-        const { delay, randomMinutes } = this.calculateDelay();
-        if (Date.now() > lastPostTimestamp + delay) {
-          await this.generateNewCast();
-        }
-        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 cast loop:", this.runtime.agentId, error);
-      }
-    }
-  }
-  async generateNewCast() {
-    logger3.info("Generating new cast");
-    try {
-      const worldId = createUniqueUuid2(this.runtime, this.fid.toString());
-      const roomId = createUniqueUuid2(this.runtime, `${this.fid}-home`);
-      const callback = standardCastHandlerCallback({
-        client: this.client,
-        runtime: this.runtime,
-        config: this.config,
-        roomId,
-        onCompletion: async (casts, _memories) => {
-          const lastCast = casts[casts.length - 1];
-          await this.runtime.setCache(lastCastCacheKey(this.fid), {
-            hash: lastCast.hash,
-            timestamp: new Date(lastCast.timestamp).getTime()
-          });
-        }
-      });
-      this.runtime.emitEvent([EventType2.POST_GENERATED, "FARCASTER_CAST_GENERATED" /* CAST_GENERATED */], {
-        runtime: this.runtime,
-        callback,
-        worldId,
-        userId: this.runtime.agentId,
-        roomId,
-        source: FARCASTER_SOURCE
-      });
-    } catch (error) {
-      logger3.error("Error generating new cast:", error);
-    }
+    logger3.info("Stopping Farcaster interaction manager");
+    await this.source.stop();
   }
-};
+}
 
 // src/managers/agent.ts
-var FarcasterAgentManager = class {
+class FarcasterAgentManager {
   runtime;
   client;
   casts;
@@ -783,8 +1119,8 @@ var FarcasterAgentManager = class {
     const client = new FarcasterClient({ neynar, signerUuid });
     this.client = client;
     logger4.success("Farcaster Neynar client initialized.");
-    this.casts = new FarcasterCastManager({ client, runtime, config });
     this.interactions = new FarcasterInteractionManager({ client, runtime, config });
+    this.casts = new FarcasterCastManager({ client, runtime, config });
   }
   async start() {
     await Promise.all([this.casts.start(), this.interactions.start()]);
@@ -792,13 +1128,15 @@ var FarcasterAgentManager = class {
   async stop() {
     await Promise.all([this.casts.stop(), this.interactions.stop()]);
   }
-};
+}
 
 // src/common/config.ts
+init_constants();
 import { logger as logger5, parseBooleanFromText } from "@elizaos/core";
 import { ZodError } from "zod";
 function safeParseInt(value, defaultValue) {
-  if (!value) return defaultValue;
+  if (!value)
+    return defaultValue;
   const parsed = Number.parseInt(value, 10);
   return Number.isNaN(parsed) ? defaultValue : Math.max(1, parsed);
 }
@@ -813,38 +1151,20 @@ function validateFarcasterConfig(runtime) {
   try {
     const farcasterConfig = {
       FARCASTER_DRY_RUN: runtime.getSetting("FARCASTER_DRY_RUN") || parseBooleanFromText(process.env.FARCASTER_DRY_RUN || "false"),
-      FARCASTER_FID: Number.isNaN(fid) ? void 0 : fid,
-      MAX_CAST_LENGTH: safeParseInt(
-        runtime.getSetting("MAX_CAST_LENGTH") || process.env.MAX_CAST_LENGTH,
-        DEFAULT_MAX_CAST_LENGTH
-      ),
-      FARCASTER_POLL_INTERVAL: safeParseInt(
-        runtime.getSetting("FARCASTER_POLL_INTERVAL") || process.env.FARCASTER_POLL_INTERVAL,
-        DEFAULT_POLL_INTERVAL
-      ),
+      FARCASTER_FID: Number.isNaN(fid) ? undefined : fid,
+      MAX_CAST_LENGTH: safeParseInt(runtime.getSetting("MAX_CAST_LENGTH") || process.env.MAX_CAST_LENGTH, DEFAULT_MAX_CAST_LENGTH),
+      FARCASTER_POLL_INTERVAL: safeParseInt(runtime.getSetting("FARCASTER_POLL_INTERVAL") || process.env.FARCASTER_POLL_INTERVAL, DEFAULT_POLL_INTERVAL),
       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
-      ),
-      CAST_INTERVAL_MAX: safeParseInt(
-        runtime.getSetting("CAST_INTERVAL_MAX") || process.env.CAST_INTERVAL_MAX,
-        DEFAULT_CAST_INTERVAL_MAX
-      ),
+      CAST_INTERVAL_MIN: safeParseInt(runtime.getSetting("CAST_INTERVAL_MIN") || process.env.CAST_INTERVAL_MIN, DEFAULT_CAST_INTERVAL_MIN),
+      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(
-        runtime.getSetting("ACTION_INTERVAL") || process.env.ACTION_INTERVAL,
-        5
-      ),
-      // 5 minutes
+      ACTION_INTERVAL: safeParseInt(runtime.getSetting("ACTION_INTERVAL") || process.env.ACTION_INTERVAL, 5),
       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
-      ),
+      MAX_ACTIONS_PROCESSING: safeParseInt(runtime.getSetting("MAX_ACTIONS_PROCESSING") || process.env.MAX_ACTIONS_PROCESSING, 1),
       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"
+      FARCASTER_HUB_URL: runtime.getSetting("FARCASTER_HUB_URL") || process.env.FARCASTER_HUB_URL || "hub.pinata.cloud",
+      FARCASTER_MODE: runtime.getSetting("FARCASTER_MODE") || process.env.FARCASTER_MODE || "polling"
     };
     const config = FarcasterConfigSchema.parse(farcasterConfig);
     const isDryRun = config.FARCASTER_DRY_RUN;
@@ -853,9 +1173,7 @@ function validateFarcasterConfig(runtime) {
     logger5.log(`- Dry Run Mode: ${isDryRun ? "enabled" : "disabled"}`);
     logger5.log(`- Enable Cast: ${config.ENABLE_CAST ? "enabled" : "disabled"}`);
     if (config.ENABLE_CAST) {
-      logger5.log(
-        `- Cast Interval: ${config.CAST_INTERVAL_MIN}-${config.CAST_INTERVAL_MAX} minutes`
-      );
+      logger5.log(`- Cast Interval: ${config.CAST_INTERVAL_MIN}-${config.CAST_INTERVAL_MAX} minutes`);
       logger5.log(`- Cast Immediately: ${config.CAST_IMMEDIATELY ? "enabled" : "disabled"}`);
     }
     logger5.log(`- Action Processing: ${config.ENABLE_ACTION_PROCESSING ? "enabled" : "disabled"}`);
@@ -866,7 +1184,8 @@ function validateFarcasterConfig(runtime) {
     return config;
   } catch (error) {
     if (error instanceof ZodError) {
-      const errorMessages = error.errors.map((err) => `${err.path.join(".")}: ${err.message}`).join("\n");
+      const errorMessages = error.issues.map((err) => `${err.path.join(".")}: ${err.message}`).join(`
+`);
       throw new Error(`Farcaster configuration validation failed:
 ${errorMessages}`);
     }
@@ -875,64 +1194,74 @@ ${errorMessages}`);
 }
 
 // src/services/MessageService.ts
-import {
-  logger as logger6,
-  createUniqueUuid as createUniqueUuid3
-} from "@elizaos/core";
-var FarcasterMessageService = class {
+import { createUniqueUuid as createUniqueUuid3 } from "@elizaos/core";
+init_constants();
+class FarcasterMessageService {
+  client;
+  runtime;
   constructor(client, runtime) {
     this.client = client;
     this.runtime = runtime;
   }
+  castToMessage(cast, agentId, extraMetadata) {
+    return {
+      id: castUuid({ hash: cast.hash, agentId }),
+      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 }) : undefined,
+      metadata: {
+        source: FARCASTER_SOURCE,
+        castHash: cast.hash,
+        threadId: cast.threadId,
+        authorFid: cast.authorFid,
+        ...extraMetadata || {}
+      }
+    };
+  }
   async getMessages(options) {
     try {
-      const { roomId, limit = 20 } = options;
+      const { agentId, roomId, limit = 20 } = options;
+      const fidStr = this.runtime.getSetting("FARCASTER_FID");
+      const fid = fidStr ? parseInt(fidStr, 10) : NaN;
+      if (!fid || isNaN(fid)) {
+        this.runtime.logger.error("[Farcaster] FARCASTER_FID is not configured");
+        return [];
+      }
       const { timeline } = await this.client.getTimeline({
-        fid: parseInt(
-          this.runtime.getSetting("FARCASTER_FID") || this.runtime.config.FARCASTER_FID
-        ),
+        fid,
         pageSize: limit
       });
-      const messages = timeline.filter((cast) => {
+      const messages = timeline.map((cast) => this.castToMessage(cast, agentId)).filter((message) => {
         if (roomId) {
-          const castRoomId = createUniqueUuid3(this.runtime, cast.threadId || cast.hash);
-          return castRoomId === roomId;
+          return message.roomId === 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);
+      this.runtime.logger.error({ error }, "[Farcaster] Error fetching messages");
       return [];
     }
   }
   async sendMessage(options) {
-    var _a;
     try {
       const { text, type, roomId, replyToId, agentId } = options;
-      let inReplyTo = void 0;
+      let inReplyTo = undefined;
       if (replyToId && type === "REPLY" /* REPLY */) {
-        const parentHash = ((_a = options.metadata) == null ? void 0 : _a.parentHash) || replyToId;
+        const parentHash = options.metadata?.parentHash || replyToId;
+        const fidStr = this.runtime.getSetting("FARCASTER_FID");
+        const fid = fidStr ? parseInt(fidStr, 10) : NaN;
+        if (!fid || isNaN(fid)) {
+          throw new Error("FARCASTER_FID is not configured");
+        }
         inReplyTo = {
           hash: parentHash,
-          fid: parseInt(
-            this.runtime.getSetting("FARCASTER_FID") || this.runtime.config.FARCASTER_FID
-          )
+          fid
         };
       }
       const casts = await this.client.sendCast({
@@ -943,23 +1272,9 @@ var FarcasterMessageService = class {
         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
-        }
-      };
+      const message = this.castToMessage(cast, agentId, options.metadata);
+      message.roomId = roomId;
+      message.type = type;
       await this.runtime.emitEvent("FARCASTER_CAST_GENERATED" /* CAST_GENERATED */, {
         runtime: this.runtime,
         castHash: cast.hash,
@@ -968,78 +1283,84 @@ var FarcasterMessageService = class {
       });
       return message;
     } catch (error) {
-      logger6.error("[Farcaster] Error sending message:", error);
+      this.runtime.logger.error({ error }, "[Farcaster] Error sending message");
       throw error;
     }
   }
   async deleteMessage(messageId, agentId) {
-    logger6.warn("[Farcaster] Cast deletion is not supported by the Farcaster API");
+    this.runtime.logger.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;
+      return this.castToMessage(farcasterCast, agentId);
     } catch (error) {
-      logger6.error("[Farcaster] Error fetching message:", error);
+      this.runtime.logger.error({ error }, "[Farcaster] Error fetching message");
       return null;
     }
   }
+  async getThread(params) {
+    try {
+      const thread = [];
+      const visited = new Set;
+      let currentHash = params.castHash;
+      while (currentHash) {
+        if (visited.has(currentHash)) {
+          break;
+        }
+        visited.add(currentHash);
+        const cast = neynarCastToCast(await this.client.getCast(currentHash));
+        thread.unshift(this.castToMessage(cast, params.agentId));
+        currentHash = cast.inReplyTo?.hash;
+      }
+      return thread;
+    } catch (error) {
+      this.runtime.logger.error({ error }, "[Farcaster] Error fetching thread");
+      return [];
+    }
+  }
   async markAsRead(messageIds, agentId) {
-    logger6.debug("[Farcaster] Mark as read is not applicable for Farcaster casts");
+    this.runtime.logger.debug("[Farcaster] Mark as read is not applicable for Farcaster casts");
   }
-};
+}
 
 // src/services/CastService.ts
 import {
-  logger as logger7,
+  logger as logger6,
   ModelType as ModelType2,
   createUniqueUuid as createUniqueUuid4
 } from "@elizaos/core";
-var FarcasterCastService = class {
+init_constants();
+
+class FarcasterCastService {
+  client;
+  runtime;
+  static serviceType = "ICastService";
   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 fidStr = this.runtime.getSetting("FARCASTER_FID");
+      const fid = fidStr ? parseInt(fidStr, 10) : NaN;
+      if (!fid || isNaN(fid)) {
+        logger6.error("FARCASTER_FID is not configured");
+        return [];
+      }
       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),
+        fid,
         pageSize: params.limit || 50
       });
       return timeline.map((cast) => this.castToFarcasterCast(cast, params.agentId));
     } catch (error) {
-      logger7.error("Failed to get casts", { params, error });
+      logger6.error(`Failed to get casts: ${JSON.stringify({ params, error })}`);
       return [];
     }
   }
-  /**
-   * Create a new cast
-   */
   async createCast(params) {
-    var _a;
     try {
       let castText = params.text;
       if (!castText || castText.trim() === "") {
@@ -1050,7 +1371,7 @@ var FarcasterCastService = class {
       }
       const casts = await this.client.sendCast({
         content: { text: castText },
-        inReplyTo: params.replyTo ? { hash: params.replyTo.hash, fid: params.replyTo.fid } : void 0
+        inReplyTo: params.replyTo ? { hash: params.replyTo.hash, fid: params.replyTo.fid } : undefined
       });
       if (casts.length === 0) {
         throw new Error("No cast was created");
@@ -1064,9 +1385,8 @@ var FarcasterCastService = class {
         username: cast.profile.username,
         text: cast.text,
         timestamp: cast.timestamp.getTime(),
-        inReplyTo: (_a = params.replyTo) == null ? void 0 : _a.hash,
+        inReplyTo: params.replyTo?.hash,
         media: [],
-        // TODO: Handle media upload when Farcaster API supports it
         metadata: {
           castHash: cast.hash,
           threadId: cast.threadId,
@@ -1077,73 +1397,60 @@ var FarcasterCastService = class {
       await this.storeCastInMemory(params.roomId, farcasterCast);
       return farcasterCast;
     } catch (error) {
-      logger7.error("Failed to create cast", { params, error });
+      logger6.error(`Failed to create cast: ${JSON.stringify({ 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 });
+      logger6.warn(`Cast deletion is not supported by the Farcaster API: ${JSON.stringify({ castHash: params.castHash })}`);
     } catch (error) {
-      logger7.error("Failed to delete cast", { params, error });
+      logger6.error(`Failed to delete cast: ${JSON.stringify({ params, error })}`);
       throw error;
     }
   }
-  /**
-   * Like a cast
-   */
   async likeCast(params) {
     try {
-      logger7.info("Like functionality not yet implemented for cast", { castHash: params.castHash });
+      logger6.info(`Like functionality not yet implemented for cast: ${JSON.stringify({ castHash: params.castHash })}`);
     } catch (error) {
-      logger7.error("Failed to like cast", { params, error });
+      logger6.error(`Failed to like cast: ${JSON.stringify({ params, error })}`);
       throw error;
     }
   }
-  /**
-   * Unlike a cast
-   */
   async unlikeCast(params) {
     try {
-      logger7.info("Unlike functionality not yet implemented for cast", { castHash: params.castHash });
+      logger6.info(`Unlike functionality not yet implemented for cast: ${JSON.stringify({ castHash: params.castHash })}`);
     } catch (error) {
-      logger7.error("Failed to unlike cast", { params, error });
+      logger6.error(`Failed to unlike cast: ${JSON.stringify({ params, error })}`);
       throw error;
     }
   }
-  /**
-   * Recast a cast
-   */
   async recast(params) {
     try {
-      logger7.info("Recast functionality not yet implemented for cast", { castHash: params.castHash });
+      logger6.info(`Recast functionality not yet implemented for cast: ${JSON.stringify({ castHash: params.castHash })}`);
     } catch (error) {
-      logger7.error("Failed to recast", { params, error });
+      logger6.error(`Failed to recast: ${JSON.stringify({ params, error })}`);
       throw error;
     }
   }
-  /**
-   * Remove a recast
-   */
   async unrecast(params) {
     try {
-      logger7.info("Remove recast functionality not yet implemented for cast", { castHash: params.castHash });
+      logger6.info(`Remove recast functionality not yet implemented for cast: ${JSON.stringify({ castHash: params.castHash })}`);
     } catch (error) {
-      logger7.error("Failed to remove recast", { params, error });
+      logger6.error(`Failed to remove recast: ${JSON.stringify({ params, error })}`);
       throw error;
     }
   }
-  /**
-   * Get mentions
-   */
   async getMentions(params) {
-    var _a, _b;
     try {
+      const fidStr = this.runtime.getSetting("FARCASTER_FID");
+      const fid = fidStr ? parseInt(fidStr, 10) : NaN;
+      if (!fid || isNaN(fid)) {
+        logger6.error("FARCASTER_FID is not configured");
+        return [];
+      }
       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),
+        fid,
         pageSize: params.limit || 20
       });
       return mentions.map((castWithInteractions) => {
@@ -1151,13 +1458,10 @@ var FarcasterCastService = class {
         return this.castToFarcasterCast(cast, params.agentId);
       });
     } catch (error) {
-      logger7.error("Failed to get mentions", { params, error });
+      logger6.error(`Failed to get mentions: ${JSON.stringify({ 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 {
@@ -1167,13 +1471,10 @@ var FarcasterCastService = class {
       });
       return response;
     } catch (error) {
-      logger7.error("Failed to generate cast content", { error });
-      return "Hello Farcaster! \u{1F44B}";
+      logger6.error(`Failed to generate cast content: ${JSON.stringify({ error })}`);
+      return "Hello Farcaster! \uD83D\uDC4B";
     }
   }
-  /**
-   * 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 {
@@ -1187,22 +1488,18 @@ var FarcasterCastService = class {
       }
       return truncated;
     } catch (error) {
-      logger7.error("Failed to truncate cast", { error });
+      logger6.error(`Failed to truncate cast: ${JSON.stringify({ 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,
+          castHash: cast.metadata?.castHash,
           castId: cast.id,
           author: cast.username,
           timestamp: cast.timestamp
@@ -1216,15 +1513,12 @@ var FarcasterCastService = class {
       } 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");
+        logger6.warn("Memory storage method not available in runtime");
       }
     } catch (error) {
-      logger7.error("Failed to store cast in memory", { error });
+      logger6.error(`Failed to store cast in memory: ${JSON.stringify({ error })}`);
     }
   }
-  /**
-   * Convert internal Cast type to FarcasterCast
-   */
   castToFarcasterCast(cast, agentId) {
     return {
       id: castUuid({ hash: cast.hash, agentId }),
@@ -1235,7 +1529,6 @@ var FarcasterCastService = class {
       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,
@@ -1245,39 +1538,35 @@ var FarcasterCastService = class {
       }
     };
   }
-};
+}
 
 // src/service.ts
-var FarcasterService = class _FarcasterService extends Service {
+class FarcasterService extends Service {
   static instance;
-  managers = /* @__PURE__ */ new Map();
-  messageServices = /* @__PURE__ */ new Map();
-  castServices = /* @__PURE__ */ new Map();
-  // Properly implement serviceType for discoverability
+  managers = new Map;
+  messageServices = new Map;
+  castServices = new Map;
   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) {
-      _FarcasterService.instance = new _FarcasterService();
+    if (!FarcasterService.instance) {
+      FarcasterService.instance = new FarcasterService;
     }
-    return _FarcasterService.instance;
+    return FarcasterService.instance;
   }
-  // Required by ElizaOS Service base class
   async initialize(runtime) {
-    await _FarcasterService.start(runtime);
+    await FarcasterService.start(runtime);
   }
-  // Called to start a single Farcaster service
   static async start(runtime) {
-    const service = _FarcasterService.getInstance();
+    const service = FarcasterService.getInstance();
     let manager = service.managers.get(runtime.agentId);
     if (manager) {
-      logger8.warn("Farcaster service already started", runtime.agentId);
+      logger7.warn({ agentId: runtime.agentId }, "Farcaster service already started");
       return service;
     }
     if (!hasFarcasterEnabled(runtime)) {
-      logger8.debug("Farcaster service not enabled", runtime.agentId);
+      logger7.debug({ agentId: runtime.agentId }, "Farcaster service not enabled");
       return service;
     }
     const farcasterConfig = validateFarcasterConfig(runtime);
@@ -1288,59 +1577,48 @@ var FarcasterService = class _FarcasterService extends Service {
     service.messageServices.set(runtime.agentId, messageService);
     service.castServices.set(runtime.agentId, castService);
     await manager.start();
-    logger8.success("Farcaster client started", runtime.agentId);
+    logger7.success({ agentId: runtime.agentId }, "Farcaster client started");
     return service;
   }
-  // Called to stop a single Farcaster service
   static async stop(runtime) {
-    const service = _FarcasterService.getInstance();
+    const service = FarcasterService.getInstance();
     let manager = service.managers.get(runtime.agentId);
     if (manager) {
       await manager.stop();
       service.managers.delete(runtime.agentId);
       service.messageServices.delete(runtime.agentId);
       service.castServices.delete(runtime.agentId);
-      logger8.info("Farcaster client stopped", runtime.agentId);
+      logger7.info({ agentId: runtime.agentId }, "Farcaster client stopped");
     } else {
-      logger8.debug("Farcaster service not running", runtime.agentId);
+      logger7.debug({ agentId: runtime.agentId }, "Farcaster service not running");
     }
   }
-  // Called to stop all Farcaster services
   async stop() {
-    logger8.debug("Stopping ALL Farcaster services");
+    logger7.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);
+        await FarcasterService.stop(manager.runtime);
       } catch (error) {
-        logger8.error("Error stopping Farcaster service", agentId, error);
+        logger7.error({ agentId, error }, "Error stopping Farcaster service");
       }
     }
   }
-  // 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"))
-        );
+        const profile = await manager.client.getProfile(parseInt(manager.runtime.getSetting("FARCASTER_FID")));
         managerStatuses[agentId] = {
           status: "healthy",
           fid: profile.fid,
@@ -1362,16 +1640,16 @@ var FarcasterService = class _FarcasterService extends Service {
       }
     };
   }
-  // Get all active managers (for monitoring)
   getActiveManagers() {
     return new Map(this.managers);
   }
-};
+}
 
 // src/__tests__/suite.ts
+init_constants();
 import {
   ModelType as ModelType3,
-  createUniqueUuid as createUniqueUuid6,
+  createUniqueUuid as createUniqueUuid7,
   logger as logger10
 } from "@elizaos/core";
 
@@ -1389,27 +1667,27 @@ var TEST_IMAGE = {
 };
 
 // src/__tests__/e2e/scenarios.ts
-import { logger as logger9, createUniqueUuid as createUniqueUuid5 } from "@elizaos/core";
+init_constants();
+import { logger as logger9, createUniqueUuid as createUniqueUuid6 } 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 castService = service.getCastService(runtime.agentId);
+      if (!castService) {
+        throw new Error("CastService 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({
+      const introText = `Hello Farcaster! I'm ${runtime.character.name}, an AI agent powered by ElizaOS. Looking forward to connecting with you all! \uD83E\uDD16`;
+      const cast = await castService.createCast({
         agentId: runtime.agentId,
-        roomId: createUniqueUuid5(runtime, "farcaster-timeline"),
+        roomId: createUniqueUuid6(runtime, "farcaster-timeline"),
         text: introText
       });
-      if (!cast || !cast.id || !cast.text || !((_a = cast.metadata) == null ? void 0 : _a.castHash)) {
+      if (!cast || !cast.id || !cast.text || !cast.metadata?.castHash) {
         throw new Error("Failed to create introduction cast");
       }
       logger9.info(`Posted introduction cast: ${cast.metadata.castHash}`);
@@ -1432,11 +1710,11 @@ var farcasterE2EScenarios = [
       if (!service) {
         throw new Error("Farcaster service not initialized");
       }
-      const postService = service.getPostService(runtime.agentId);
-      if (!postService) {
-        throw new Error("PostService not available");
+      const castService = service.getCastService(runtime.agentId);
+      if (!castService) {
+        throw new Error("CastService not available");
       }
-      const casts = await postService.getPosts({
+      const casts = await castService.getCasts({
         agentId: runtime.agentId,
         limit: 10
       });
@@ -1451,7 +1729,7 @@ var farcasterE2EScenarios = [
         }
         logger9.info(`Latest cast by @${firstCast.username}: ${firstCast.text.substring(0, 50)}...`);
       }
-      const mentions = await postService.getMentions(runtime.agentId, { limit: 5 });
+      const mentions = await castService.getMentions({ agentId: runtime.agentId, limit: 5 });
       if (!Array.isArray(mentions)) {
         throw new Error("getMentions did not return an array");
       }
@@ -1461,7 +1739,6 @@ var farcasterE2EScenarios = [
   {
     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");
@@ -1470,14 +1747,14 @@ var farcasterE2EScenarios = [
       if (!messageService) {
         throw new Error("MessageService not available");
       }
-      const roomId = createUniqueUuid5(runtime, "test-conversation");
+      const roomId = createUniqueUuid6(runtime, "test-conversation");
       const message = await messageService.sendMessage({
         agentId: runtime.agentId,
         roomId,
-        text: "Testing message send and retrieve with ElizaOS Farcaster plugin! \u{1F9EA}",
+        text: "Testing message send and retrieve with ElizaOS Farcaster plugin! \uD83E\uDDEA",
         type: "CAST" /* CAST */
       });
-      if (!message || !message.id || !((_a = message.metadata) == null ? void 0 : _a.castHash)) {
+      if (!message || !message.id || !message.metadata?.castHash) {
         throw new Error("Failed to send message or missing metadata");
       }
       logger9.info(`Sent cast with hash: ${message.metadata.castHash}`);
@@ -1492,35 +1769,34 @@ var farcasterE2EScenarios = [
   {
     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) {
+      const castService = service.getCastService(runtime.agentId);
+      if (!messageService || !castService) {
         throw new Error("Services not available");
       }
-      const originalCast = await postService.createPost({
+      const originalCast = await castService.createCast({
         agentId: runtime.agentId,
-        roomId: createUniqueUuid5(runtime, "reply-test"),
-        text: "This is a test cast for reply threading \u{1F9F5}"
+        roomId: createUniqueUuid6(runtime, "reply-test"),
+        text: "This is a test cast for reply threading \uD83E\uDDF5"
       });
-      if (!originalCast || !((_a = originalCast.metadata) == null ? void 0 : _a.castHash)) {
+      if (!originalCast || !originalCast.metadata?.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}",
+        text: "This is a test reply maintaining thread context! \uD83D\uDCAC",
         type: "REPLY",
         replyToId: originalCast.metadata.castHash,
         metadata: {
           parentHash: originalCast.metadata.castHash
         }
       });
-      if (!reply || !reply.inReplyTo || !((_b = reply.metadata) == null ? void 0 : _b.castHash)) {
+      if (!reply || !reply.inReplyTo || !reply.metadata?.castHash) {
         throw new Error("Failed to create reply or missing thread context");
       }
       logger9.info(`Created reply ${reply.metadata.castHash} to ${originalCast.metadata.castHash}`);
@@ -1529,11 +1805,11 @@ var farcasterE2EScenarios = [
   {
     name: "Farcaster Plugin - Action Execution",
     async fn(runtime) {
-      const { sendCastAction: sendCastAction2 } = await import("./sendCast-OW6DBKQB.js");
+      const { sendCastAction: sendCastAction2 } = await Promise.resolve().then(() => (init_sendCast(), exports_sendCast));
       const mockMessage = {
-        id: createUniqueUuid5(runtime, "test-message"),
+        id: createUniqueUuid6(runtime, "test-message"),
         agentId: runtime.agentId,
-        roomId: createUniqueUuid5(runtime, "test-room"),
+        roomId: createUniqueUuid6(runtime, "test-room"),
         entityId: runtime.agentId,
         content: {
           text: "Can you post about the ElizaOS framework on Farcaster?"
@@ -1544,34 +1820,30 @@ var farcasterE2EScenarios = [
       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");
-      }
+      await sendCastAction2.handler(runtime, mockMessage);
       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 { farcasterProfileProvider: farcasterProfileProvider2 } = await Promise.resolve().then(() => (init_profileProvider(), exports_profileProvider));
+      const { farcasterTimelineProvider: farcasterTimelineProvider2 } = await Promise.resolve().then(() => (init_timelineProvider(), exports_timelineProvider));
       const mockMessage = {
-        id: createUniqueUuid5(runtime, "test-message"),
+        id: createUniqueUuid6(runtime, "test-message"),
         agentId: runtime.agentId,
-        roomId: createUniqueUuid5(runtime, "test-room"),
+        roomId: createUniqueUuid6(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) {
+      if (!profileContext || !profileContext.text || profileContext.data?.available === undefined) {
         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) {
+      if (!timelineContext || !timelineContext.text || timelineContext.data?.available === undefined) {
         throw new Error("Timeline provider returned invalid context");
       }
       logger9.info(`Timeline provider: ${timelineContext.text}`);
@@ -1589,18 +1861,16 @@ var farcasterE2EScenarios = [
         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;
-          })
-        );
+      for (let i = 0;i < 3; i++) {
+        promises.push(messageService.sendMessage({
+          agentId: runtime.agentId,
+          roomId: createUniqueUuid6(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);
@@ -1618,13 +1888,13 @@ var farcasterE2EScenarios = [
         throw new Error("Farcaster service not initialized");
       }
       const health = await service.healthCheck();
-      if (!health || health.healthy === void 0 || !health.details) {
+      if (!health || health.healthy === undefined || !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);
+        logger9.warn({ details: health.details }, "Service reported unhealthy status");
       }
     }
   },
@@ -1635,15 +1905,15 @@ var farcasterE2EScenarios = [
       if (!service) {
         throw new Error("FarcasterService not found");
       }
-      const postService = service.getPostService(runtime.agentId);
-      if (!postService) {
-        throw new Error("PostService not available");
+      const castService = service.getCastService(runtime.agentId);
+      if (!castService) {
+        throw new Error("CastService not available");
       }
-      const uniqueMessage = `This is a real E2E test cast from ElizaOS! ID: ${createUniqueUuid5(runtime, "e2e-cast")}`;
+      const uniqueMessage = `This is a real E2E test cast from ElizaOS! ID: ${createUniqueUuid6(runtime, "e2e-cast")}`;
       logger9.info(`Attempting to post cast: "${uniqueMessage}"`);
-      const cast = await postService.createPost({
+      const cast = await castService.createCast({
         agentId: runtime.agentId,
-        roomId: createUniqueUuid5(runtime, "farcaster-e2e-test"),
+        roomId: createUniqueUuid6(runtime, "farcaster-e2e-test"),
         text: uniqueMessage
       });
       if (!cast || !cast.id) {
@@ -1655,30 +1925,26 @@ var farcasterE2EScenarios = [
 ];
 
 // src/__tests__/suite.ts
-var FarcasterTestSuite = class {
+class FarcasterTestSuite {
   name = "Farcaster Plugin Tests";
   description = "Test suite for Farcaster plugin functionality";
   manager = null;
   tests;
-  /**
-   * Constructor for TestSuite class.
-   * Initializes an array of test functions to be executed.
-   */
   constructor() {
     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(`FID: ${process.env.FARCASTER_FID ? "✓ Found" : "✗ Missing"}`);
+    logger10.info(`Signer UUID: ${process.env.FARCASTER_SIGNER_UUID ? "✓ Found" : "✗ Missing"}`);
+    logger10.info(`API Key: ${process.env.FARCASTER_NEYNAR_API_KEY ? "✓ Found" : "✗ 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");
+      logger10.success("✅ 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");
+      logger10.warn("⚠️  Farcaster credentials not found in environment variables");
+      logger10.warn("⚠️  Tests will run in mock mode");
+      logger10.warn("⚠️  To run real tests, set FARCASTER_FID, FARCASTER_SIGNER_UUID, and FARCASTER_NEYNAR_API_KEY");
       this.tests = [
         {
           name: "Mock: Check Farcaster Configuration",
@@ -1691,9 +1957,6 @@ var FarcasterTestSuite = class {
       ];
     }
   }
-  /**
-   * Test that checks if Farcaster is properly configured
-   */
   async testMockConfiguration(runtime) {
     logger10.info("Running mock configuration test");
     const fid = runtime.getSetting("FARCASTER_FID");
@@ -1711,9 +1974,6 @@ var FarcasterTestSuite = class {
       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 {
@@ -1724,24 +1984,18 @@ var FarcasterTestSuite = class {
       }
       logger10.info("Farcaster service is registered but may not be fully initialized");
       if (typeof service.getMessageService === "function") {
-        logger10.info("\u2713 getMessageService method exists");
+        logger10.info("✓ getMessageService method exists");
       }
       if (typeof service.getPostService === "function") {
-        logger10.info("\u2713 getPostService method exists");
+        logger10.info("✓ getPostService method exists");
       }
       if (typeof service.healthCheck === "function") {
-        logger10.info("\u2713 healthCheck method exists");
+        logger10.info("✓ healthCheck method exists");
       }
     } catch (error) {
       logger10.info("Service initialization check completed");
     }
   }
-  /**
-   * Asynchronously initializes the Farcaster client for the provided agent runtime.
-   *
-   * @param {IAgentRuntime} runtime - The agent runtime to use for initializing the Farcaster client.
-   * @throws {Error} If the Farcaster client manager is not found or if the Farcaster client fails to initialize.
-   */
   async testInitializingClient(runtime) {
     try {
       const service = runtime.getService(FARCASTER_SERVICE_NAME);
@@ -1758,12 +2012,6 @@ var FarcasterTestSuite = class {
       throw new Error(`Error in initializing Farcaster client: ${error}`);
     }
   }
-  /**
-   * Asynchronously fetches the profile of a user from Farcaster using the given runtime.
-   *
-   * @param {IAgentRuntime} runtime The runtime to use for fetching the profile.
-   * @returns {Promise<void>} A Promise that resolves when the profile is successfully fetched, or rejects with an error.
-   */
   async testFetchProfile(runtime) {
     try {
       if (!this.manager) {
@@ -1777,18 +2025,11 @@ var FarcasterTestSuite = class {
       if (!profile || !profile.fid) {
         throw new Error("Profile fetch failed.");
       }
-      logger10.log("Successfully fetched Farcaster profile:", profile);
+      runtime.logger.info({ profile }, "Successfully fetched Farcaster profile:");
     } catch (error) {
       throw new Error(`Error fetching Farcaster profile: ${error}`);
     }
   }
-  /**
-   * Asynchronously fetches the timeline from the Farcaster client.
-   *
-   * @param {IAgentRuntime} runtime - The agent runtime object.
-   * @throws {Error} If there are no casts in the timeline.
-   * @throws {Error} If an error occurs while fetching the timeline.
-   */
   async testFetchTimeline(runtime) {
     try {
       if (!this.manager) {
@@ -1808,13 +2049,6 @@ var FarcasterTestSuite = class {
       throw new Error(`Error fetching timeline: ${error}`);
     }
   }
-  /**
-   * Asynchronously posts a test cast using the Farcaster API.
-   *
-   * @param {IAgentRuntime} runtime - The agent runtime object.
-   * @returns {Promise<void>} A Promise that resolves when the cast is successfully posted.
-   * @throws {Error} If there is an error posting the cast.
-   */
   async testPostCast(runtime) {
     try {
       if (!this.manager) {
@@ -1832,14 +2066,6 @@ var FarcasterTestSuite = class {
       throw new Error(`Error posting a cast: ${error}`);
     }
   }
-  /**
-   * Asynchronously posts an image cast on Farcaster using the provided runtime and cast content.
-   * Note: This might need updating based on how images are actually handled in sendCast
-   *
-   * @param {IAgentRuntime} runtime - The runtime environment for the action.
-   * @returns {Promise<void>} A Promise that resolves when the cast is successfully posted.
-   * @throws {Error} If there is an error posting the cast.
-   */
   async testPostImageCast(runtime) {
     try {
       if (!this.manager) {
@@ -1860,13 +2086,6 @@ var FarcasterTestSuite = class {
       throw new Error(`Error posting a cast with image: ${error}`);
     }
   }
-  /**
-   * Asynchronously handles a fake cast response using the given runtime.
-   *
-   * @param {IAgentRuntime} runtime - The runtime object for the agent
-   * @returns {Promise<void>} - A promise that resolves when the cast response is handled
-   * @throws {Error} - If there is an error handling the cast response
-   */
   async testHandleCastResponse(runtime) {
     try {
       if (!this.manager) {
@@ -1881,17 +2100,17 @@ var FarcasterTestSuite = class {
           username: "randomUser",
           name: "Random User"
         },
-        timestamp: /* @__PURE__ */ new Date()
+        timestamp: new Date
       };
-      const memoryId = createUniqueUuid6(runtime, testCast.hash);
+      const memoryId = createUniqueUuid7(runtime, testCast.hash);
       const memory = {
         id: memoryId,
         agentId: runtime.agentId,
         content: {
           text: testCast.text
         },
-        entityId: createUniqueUuid6(runtime, String(testCast.authorFid)),
-        roomId: createUniqueUuid6(runtime, "test-room"),
+        entityId: createUniqueUuid7(runtime, String(testCast.authorFid)),
+        roomId: createUniqueUuid7(runtime, "test-room"),
         createdAt: testCast.timestamp.getTime()
       };
       runtime.emitEvent("farcaster.mention_received", {
@@ -1905,13 +2124,6 @@ var FarcasterTestSuite = class {
       throw new Error(`Error handling cast response: ${error}`);
     }
   }
-  /**
-   * Generates random content for a cast based on the given context.
-   *
-   * @param {IAgentRuntime} runtime - The runtime environment.
-   * @param {string} context - Optional context for the content generation.
-   * @returns {Promise<string>} A promise that resolves to the generated cast content.
-   */
   async generateRandomCastContent(runtime, context = "general") {
     const prompt = `Generate a short, interesting cast about ${context} (max 280 chars).`;
     const result = await runtime.useModel(ModelType3.TEXT_SMALL, {
@@ -1919,12 +2131,6 @@ var FarcasterTestSuite = class {
     });
     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);
@@ -1943,7 +2149,7 @@ var FarcasterTestSuite = class {
       const testText = await this.generateRandomCastContent(runtime, "message_service_test");
       const message = await messageService.sendMessage({
         agentId: runtime.agentId,
-        roomId: createUniqueUuid6(runtime, "test-room"),
+        roomId: createUniqueUuid7(runtime, "test-room"),
         text: testText,
         type: "CAST" /* CAST */
       });
@@ -1955,12 +2161,6 @@ var FarcasterTestSuite = class {
       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);
@@ -1979,7 +2179,7 @@ var FarcasterTestSuite = class {
       const testText = await this.generateRandomCastContent(runtime, "cast_service_test");
       const cast = await castService.createCast({
         agentId: runtime.agentId,
-        roomId: createUniqueUuid6(runtime, "test-room"),
+        roomId: createUniqueUuid7(runtime, "test-room"),
         text: testText
       });
       if (!cast || !cast.id) {
@@ -1990,14 +2190,7 @@ var FarcasterTestSuite = class {
       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) {
@@ -2008,35 +2201,28 @@ var FarcasterTestSuite = class {
         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}"
+        "Testing ElizaOS Farcaster integration! \uD83D\uDE80 #ElizaOS",
+        "AI agents are the future of social media engagement \uD83E\uDD16",
+        "Building amazing things with the ElizaOS framework \uD83D\uDCBB"
       ];
       for (const text of testPosts) {
         const post = await postService.createPost({
           agentId: runtime.agentId,
-          roomId: createUniqueUuid6(runtime, "real-test"),
+          roomId: createUniqueUuid7(runtime, "real-test"),
           text
         });
-        if (!post || !post.id || !((_a = post.metadata) == null ? void 0 : _a.castHash)) {
+        if (!post || !post.id || !post.metadata?.castHash) {
           throw new Error("Failed to create real post");
         }
         logger10.success(`Posted real cast: ${post.metadata.castHash}`);
-        await new Promise((resolve) => setTimeout(resolve, 1e3));
+        await new Promise((resolve) => setTimeout(resolve, 1000));
       }
       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) {
@@ -2056,18 +2242,18 @@ var FarcasterTestSuite = class {
       logger10.log(`Found ${timeline.length} timeline posts`);
       if (timeline.length > 0) {
         const targetPost = timeline[0];
-        if ((_a = targetPost.metadata) == null ? void 0 : _a.castHash) {
+        if (targetPost.metadata?.castHash) {
           const reply = await messageService.sendMessage({
             agentId: runtime.agentId,
             roomId: targetPost.roomId,
-            text: "Great post! Testing real interactions with ElizaOS \u{1F389}",
+            text: "Great post! Testing real interactions with ElizaOS \uD83C\uDF89",
             type: "REPLY" /* REPLY */,
             replyToId: targetPost.metadata.castHash,
             metadata: {
               parentHash: targetPost.metadata.castHash
             }
           });
-          if (reply && ((_b = reply.metadata) == null ? void 0 : _b.castHash)) {
+          if (reply && reply.metadata?.castHash) {
             logger10.success(`Replied to cast with: ${reply.metadata.castHash}`);
           }
         }
@@ -2077,14 +2263,7 @@ var FarcasterTestSuite = class {
       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) {
@@ -2096,11 +2275,11 @@ var FarcasterTestSuite = class {
       }
       const testMessage = await messageService.sendMessage({
         agentId: runtime.agentId,
-        roomId: createUniqueUuid6(runtime, "metadata-test"),
+        roomId: createUniqueUuid7(runtime, "metadata-test"),
         text: "Testing metadata tracking with ElizaOS",
         type: "CAST" /* CAST */
       });
-      if (!testMessage || !((_a = testMessage.metadata) == null ? void 0 : _a.castHash)) {
+      if (!testMessage || !testMessage.metadata?.castHash) {
         throw new Error("Failed to send test message");
       }
       const castHash = testMessage.metadata.castHash;
@@ -2109,7 +2288,7 @@ var FarcasterTestSuite = class {
       if (!retrievedMessage) {
         throw new Error("Failed to retrieve message by hash");
       }
-      if (((_b = retrievedMessage.metadata) == null ? void 0 : _b.castHash) !== castHash) {
+      if (retrievedMessage.metadata?.castHash !== castHash) {
         throw new Error("Metadata mismatch in retrieved message");
       }
       logger10.success("Message metadata tracking test completed successfully");
@@ -2117,12 +2296,13 @@ var FarcasterTestSuite = class {
       throw new Error(`Error testing message metadata tracking: ${error}`);
     }
   }
-};
+}
+
+// src/actions/index.ts
+init_sendCast();
 
 // src/actions/replyCast.ts
-import {
-  logger as logger11
-} from "@elizaos/core";
+init_constants();
 var replyCastAction = {
   name: "REPLY_TO_CAST",
   description: "Replies to a cast on Farcaster",
@@ -2155,31 +2335,29 @@ var replyCastAction = {
     ]
   ],
   validate: async (runtime, message) => {
-    var _a;
-    const text = ((_a = message.content.text) == null ? void 0 : _a.toLowerCase()) || "";
+    const text = message.content.text?.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));
+    const isServiceAvailable = !!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);
+      const messageService = service?.getMessageService(runtime.agentId);
       if (!messageService) {
-        logger11.error("[REPLY_TO_CAST] MessageService not available");
-        return false;
+        runtime.logger.error("[REPLY_TO_CAST] MessageService not available");
+        return;
       }
-      const parentCastHash = ((_a = message.content.metadata) == null ? void 0 : _a.parentCastHash) || (state == null ? void 0 : state.parentCastHash);
+      const parentCastHash = message.content.metadata?.parentCastHash || state?.parentCastHash;
       if (!parentCastHash) {
-        logger11.error("[REPLY_TO_CAST] No parent cast to reply to");
-        return false;
+        runtime.logger.error("[REPLY_TO_CAST] No parent cast to reply to");
+        return;
       }
       let replyContent = "";
-      if (state == null ? void 0 : state.replyContent) {
+      if (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).`;
@@ -2199,20 +2377,151 @@ var replyCastAction = {
           parentHash: parentCastHash
         }
       });
-      logger11.info(`[REPLY_TO_CAST] Successfully replied to cast: ${reply.id}`);
-      return true;
+      runtime.logger.info(`[REPLY_TO_CAST] Successfully replied to cast: ${reply.id}`);
     } catch (error) {
-      logger11.error("[REPLY_TO_CAST] Error replying to cast:", error);
-      return false;
+      runtime.logger.error("[REPLY_TO_CAST] Error replying to cast:", typeof error === "string" ? error : error.message);
+      throw error;
     }
   }
 };
 
 // src/actions/index.ts
+init_sendCast();
 var farcasterActions = [sendCastAction, replyCastAction];
 
 // src/providers/index.ts
-var farcasterProviders = [farcasterProfileProvider, farcasterTimelineProvider];
+init_profileProvider();
+init_timelineProvider();
+
+// src/providers/threadProvider.ts
+init_constants();
+var formatTimestamp = (timestamp) => {
+  return new Date(timestamp).toLocaleString("en-US", {
+    hour: "2-digit",
+    minute: "2-digit",
+    month: "short",
+    day: "numeric"
+  });
+};
+var farcasterThreadProvider = {
+  name: "farcasterThread",
+  description: "Provides thread context for Farcaster casts so the agent can reference the full conversation.",
+  get: async (runtime, message, _state) => {
+    const source = message.content?.source;
+    if (source !== FARCASTER_SOURCE) {
+      return {
+        text: "",
+        data: {
+          available: false,
+          reason: `Not a Farcaster message (source=${source ?? "unknown"})`
+        }
+      };
+    }
+    const service = runtime.getService(FARCASTER_SERVICE_NAME);
+    const messageService = service?.getMessageService(runtime.agentId);
+    if (!messageService) {
+      return {
+        text: "Farcaster message service not available.",
+        data: { available: false, error: "service_unavailable" }
+      };
+    }
+    const content = message.content;
+    const messageMetadata = message.metadata ?? {};
+    const castHash = content.hash || content.castHash || content?.metadata?.castHash || messageMetadata.castHash || content?.metadata?.parentHash || messageMetadata.parentHash;
+    if (!castHash || typeof castHash !== "string") {
+      return {
+        text: "Unable to resolve Farcaster cast hash for this message.",
+        data: { available: false, error: "missing_cast_hash" }
+      };
+    }
+    const threadMessages = await messageService.getThread({
+      agentId: runtime.agentId,
+      castHash
+    });
+    if (!threadMessages || threadMessages.length === 0) {
+      runtime.logger.debug({ castHash }, "[FarcasterThreadProvider] No thread messages retrieved for cast.");
+      return {
+        text: "No Farcaster thread context available.",
+        data: { available: false, castHash, count: 0 }
+      };
+    }
+    const formattedThread = threadMessages.map((msg, index) => {
+      const time = formatTimestamp(msg.timestamp);
+      const username = msg.username || msg.userId || "unknown";
+      const marker = index === threadMessages.length - 1 ? "→" : "•";
+      const text = msg.text && msg.text.trim().length > 0 ? msg.text : "<no text>";
+      return `${marker} [${time}] @${username}: ${text}`;
+    }).join(`
+`);
+    return {
+      text: `# Farcaster Thread Context
+${formattedThread}`,
+      data: {
+        available: true,
+        castHash,
+        count: threadMessages.length
+      },
+      values: {
+        farcasterThread: formattedThread,
+        farcasterCastHash: castHash,
+        farcasterCurrentCastText: threadMessages[threadMessages.length - 1]?.text ?? "",
+        farcasterParentCastText: threadMessages.length > 1 ? threadMessages[threadMessages.length - 2]?.text ?? "" : ""
+      }
+    };
+  }
+};
+
+// src/providers/index.ts
+init_profileProvider();
+init_timelineProvider();
+var farcasterProviders = [
+  farcasterProfileProvider,
+  farcasterTimelineProvider,
+  farcasterThreadProvider
+];
+
+// src/routes/webhook.ts
+var farcasterWebhookRoutes = [
+  {
+    type: "POST",
+    name: "Farcaster Webhook Handler",
+    path: "/webhook",
+    handler: async (req, res, runtime) => {
+      try {
+        const webhookData = req.body;
+        const eventType = webhookData.type;
+        const farcasterService = runtime?.getService?.("farcaster");
+        if (farcasterService) {
+          const agentManager = farcasterService.managers?.get?.(runtime.agentId);
+          if (agentManager && agentManager.interactions) {
+            if (agentManager.interactions.mode === "webhook") {
+              console.log("Processing webhook through FarcasterInteractionManager...");
+              await agentManager.interactions.processWebhookData(webhookData);
+            } else {
+              console.warn(`Agent is in ${agentManager.interactions.mode} mode, not webhook mode`);
+            }
+          } else {
+            console.warn(`FarcasterAgentManager not found for agent ${runtime.agentId}`);
+          }
+        } else {
+          console.warn("FarcasterService not found - webhook data logged only");
+        }
+        res.status(200).json({
+          success: true,
+          message: "Webhook processed successfully",
+          event_type: eventType,
+          timestamp: new Date().toISOString()
+        });
+      } catch (error) {
+        console.error("Webhook processing error:", error);
+        res.status(500).json({
+          success: false,
+          error: "Internal server error"
+        });
+      }
+    }
+  }
+];
 
 // src/index.ts
 var farcasterPlugin = {
@@ -2221,10 +2530,12 @@ var farcasterPlugin = {
   services: [FarcasterService],
   actions: farcasterActions,
   providers: farcasterProviders,
-  tests: [new FarcasterTestSuite()]
+  routes: farcasterWebhookRoutes,
+  tests: [new FarcasterTestSuite]
 };
-var index_default = farcasterPlugin;
+var src_default = farcasterPlugin;
 export {
-  index_default as default
+  src_default as default
 };
-//# sourceMappingURL=index.js.map
+
+//# debugId=4C5340413D630C6A64756E2164756E21