@elizaos/plugin-farcaster 1.7.2 → 2.0.0-alpha.1

package/dist/cjs/index.node.cjs

@@ -0,0 +1,2351 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// index.node.ts
+var exports_index_node = {};
+__export(exports_index_node, {
+  isEmbedUrl: () => isEmbedUrl,
+  isEmbedCast: () => isEmbedCast,
+  farcasterPlugin: () => farcasterPlugin,
+  default: () => typescript_default,
+  FarcasterService: () => FarcasterService,
+  FarcasterClient: () => FarcasterClient,
+  EmbedManager: () => EmbedManager
+});
+module.exports = __toCommonJS(exports_index_node);
+
+// actions/replyCast.ts
+var import_core = require("@elizaos/core");
+
+// generated/specs/specs.ts
+var coreActionsSpec = {
+  version: "1.0.0",
+  actions: [
+    {
+      name: "user",
+      description: "",
+      parameters: []
+    },
+    {
+      name: "user",
+      description: "",
+      parameters: []
+    }
+  ]
+};
+var allActionsSpec = {
+  version: "1.0.0",
+  actions: [
+    {
+      name: "user",
+      description: "",
+      parameters: []
+    },
+    {
+      name: "user",
+      description: "",
+      parameters: []
+    }
+  ]
+};
+var coreProvidersSpec = {
+  version: "1.0.0",
+  providers: [
+    {
+      name: "farcasterProfile",
+      description: "Provides information about the agent",
+      dynamic: true
+    },
+    {
+      name: "farcasterThread",
+      description: "Provides thread context for Farcaster casts so the agent can reference the full conversation.",
+      dynamic: true
+    },
+    {
+      name: "farcasterTimeline",
+      description: "Provides recent casts from the agent",
+      dynamic: true
+    }
+  ]
+};
+var allProvidersSpec = {
+  version: "1.0.0",
+  providers: [
+    {
+      name: "farcasterProfile",
+      description: "Provides information about the agent",
+      dynamic: true
+    },
+    {
+      name: "farcasterThread",
+      description: "Provides thread context for Farcaster casts so the agent can reference the full conversation.",
+      dynamic: true
+    },
+    {
+      name: "farcasterTimeline",
+      description: "Provides recent casts from the agent",
+      dynamic: true
+    }
+  ]
+};
+var coreEvaluatorsSpec = {
+  version: "1.0.0",
+  evaluators: []
+};
+var allEvaluatorsSpec = {
+  version: "1.0.0",
+  evaluators: []
+};
+var coreActionDocs = coreActionsSpec.actions;
+var allActionDocs = allActionsSpec.actions;
+var coreProviderDocs = coreProvidersSpec.providers;
+var allProviderDocs = allProvidersSpec.providers;
+var coreEvaluatorDocs = coreEvaluatorsSpec.evaluators;
+var allEvaluatorDocs = allEvaluatorsSpec.evaluators;
+
+// generated/specs/spec-helpers.ts
+var coreActionMap = new Map(coreActionDocs.map((doc) => [doc.name, doc]));
+var allActionMap = new Map(allActionDocs.map((doc) => [doc.name, doc]));
+var coreProviderMap = new Map(coreProviderDocs.map((doc) => [doc.name, doc]));
+var allProviderMap = new Map(allProviderDocs.map((doc) => [doc.name, doc]));
+var coreEvaluatorMap = new Map(coreEvaluatorDocs.map((doc) => [doc.name, doc]));
+var allEvaluatorMap = new Map(allEvaluatorDocs.map((doc) => [doc.name, doc]));
+function getActionSpec(name) {
+  return coreActionMap.get(name) ?? allActionMap.get(name);
+}
+function requireActionSpec(name) {
+  const spec = getActionSpec(name);
+  if (!spec) {
+    throw new Error(`Action spec not found: ${name}`);
+  }
+  return spec;
+}
+function getProviderSpec(name) {
+  return coreProviderMap.get(name) ?? allProviderMap.get(name);
+}
+function requireProviderSpec(name) {
+  const spec = getProviderSpec(name);
+  if (!spec) {
+    throw new Error(`Provider spec not found: ${name}`);
+  }
+  return spec;
+}
+
+// types/index.ts
+var import_zod = require("zod");
+var DEFAULT_MAX_CAST_LENGTH = 320;
+var DEFAULT_POLL_INTERVAL = 120;
+var DEFAULT_CAST_INTERVAL_MIN = 90;
+var DEFAULT_CAST_INTERVAL_MAX = 180;
+var DEFAULT_CAST_CACHE_TTL = 1000 * 30 * 60;
+var DEFAULT_CAST_CACHE_SIZE = 9000;
+var FarcasterConfigSchema = import_zod.z.object({
+  FARCASTER_DRY_RUN: import_zod.z.union([import_zod.z.boolean(), import_zod.z.string()]).transform((val) => typeof val === "string" ? val.toLowerCase() === "true" : val),
+  FARCASTER_FID: import_zod.z.number().int().min(1, "Farcaster fid is required"),
+  MAX_CAST_LENGTH: import_zod.z.number().int().default(DEFAULT_MAX_CAST_LENGTH),
+  FARCASTER_POLL_INTERVAL: import_zod.z.number().int().default(DEFAULT_POLL_INTERVAL),
+  FARCASTER_MODE: import_zod.z.enum(["polling", "webhook"]).default("polling"),
+  ENABLE_CAST: import_zod.z.union([import_zod.z.boolean(), import_zod.z.string()]).transform((val) => typeof val === "string" ? val.toLowerCase() === "true" : val),
+  CAST_INTERVAL_MIN: import_zod.z.number().int(),
+  CAST_INTERVAL_MAX: import_zod.z.number().int(),
+  ENABLE_ACTION_PROCESSING: import_zod.z.union([import_zod.z.boolean(), import_zod.z.string()]).transform((val) => typeof val === "string" ? val.toLowerCase() === "true" : val),
+  ACTION_INTERVAL: import_zod.z.number().int(),
+  CAST_IMMEDIATELY: import_zod.z.union([import_zod.z.boolean(), import_zod.z.string()]).transform((val) => typeof val === "string" ? val.toLowerCase() === "true" : val),
+  MAX_ACTIONS_PROCESSING: import_zod.z.number().int(),
+  FARCASTER_SIGNER_UUID: import_zod.z.string().min(1, "FARCASTER_SIGNER_UUID is not set"),
+  FARCASTER_NEYNAR_API_KEY: import_zod.z.string().min(1, "FARCASTER_NEYNAR_API_KEY is not set"),
+  FARCASTER_HUB_URL: import_zod.z.string().min(1, "FARCASTER_HUB_URL is not set")
+});
+var FARCASTER_SERVICE_NAME = "farcaster";
+var FARCASTER_SOURCE = "farcaster";
+
+// actions/replyCast.ts
+var spec = requireActionSpec("REPLY_CAST");
+var replyCastAction = {
+  name: spec.name,
+  description: spec.description,
+  examples: [
+    [
+      {
+        name: "user",
+        content: {
+          text: "Someone asked about ElizaOS on Farcaster, can you reply?"
+        }
+      },
+      {
+        name: "assistant",
+        content: {
+          text: "I'll reply to their question about ElizaOS.",
+          actions: ["REPLY_TO_CAST"]
+        }
+      }
+    ],
+    [
+      {
+        name: "user",
+        content: { text: "Reply to that cast and thank them for the feedback" }
+      },
+      {
+        name: "assistant",
+        content: {
+          text: "I'll reply with a thank you message.",
+          actions: ["REPLY_TO_CAST"]
+        }
+      }
+    ]
+  ],
+  validate: async (runtime, message) => {
+    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?.getMessageService(runtime.agentId);
+    return hasKeyword && (hasParentCast || isServiceAvailable);
+  },
+  handler: async (runtime, message, state) => {
+    try {
+      const service = runtime.getService(FARCASTER_SERVICE_NAME);
+      const messageService = service?.getMessageService(runtime.agentId);
+      if (!messageService) {
+        runtime.logger.error("[REPLY_TO_CAST] MessageService not available");
+        return { success: false, error: "MessageService not available" };
+      }
+      const metadata = message.content.metadata;
+      const stateParentCastHash = typeof state?.parentCastHash === "string" ? state.parentCastHash : undefined;
+      const parentCastHash = metadata?.parentCastHash ?? stateParentCastHash;
+      if (!parentCastHash) {
+        runtime.logger.error("[REPLY_TO_CAST] No parent cast to reply to");
+        return { success: false, error: "No parent cast to reply to" };
+      }
+      let 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).`;
+        const response = await runtime.useModel(import_core.ModelType.TEXT_LARGE, { prompt });
+        replyContent = typeof response === "string" ? response : String(response);
+      }
+      if (replyContent.length > 320) {
+        replyContent = `${replyContent.substring(0, 317)}...`;
+      }
+      const reply = await messageService.sendMessage({
+        agentId: runtime.agentId,
+        roomId: message.roomId,
+        text: replyContent,
+        type: "REPLY" /* REPLY */,
+        replyToId: parentCastHash,
+        metadata: {
+          parentHash: parentCastHash
+        }
+      });
+      runtime.logger.info(`[REPLY_TO_CAST] Successfully replied to cast: ${reply.id}`);
+      return { success: true, text: `Replied to cast: ${reply.id}` };
+    } catch (error) {
+      runtime.logger.error("[REPLY_TO_CAST] Error replying to cast:", typeof error === "string" ? error : error.message);
+      throw error;
+    }
+  }
+};
+
+// actions/sendCast.ts
+var import_core2 = require("@elizaos/core");
+var spec2 = requireActionSpec("SEND_CAST");
+var sendCastAction = {
+  name: spec2.name,
+  similes: spec2.similes ? [...spec2.similes] : [],
+  description: spec2.description,
+  examples: spec2.examples ?? [],
+  validate: async (runtime, message) => {
+    const text = message.content.text?.toLowerCase() || "";
+    const keywords = ["post", "cast", "share", "announce", "farcaster"];
+    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 { success: false, error: "PostService not available" };
+      }
+      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(import_core2.ModelType.TEXT_LARGE, { prompt });
+        castContent = typeof response === "string" ? response : String(response);
+      }
+      if (castContent.length > 320) {
+        castContent = `${castContent.substring(0, 317)}...`;
+      }
+      const cast = await postService.createCast({
+        agentId: runtime.agentId,
+        roomId: import_core2.createUniqueUuid(runtime, "farcaster-timeline"),
+        text: castContent
+      });
+      runtime.logger.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: String(cast.metadata?.castHash || ""),
+            action: "SEND_CAST"
+          }
+        },
+        createdAt: cast.timestamp
+      }, "messages");
+      return { success: true, text: `Posted cast: ${cast.id}` };
+    } catch (error) {
+      runtime.logger.error("[SEND_CAST] Error posting cast:", typeof error === "string" ? error : error.message);
+      return { success: false, error: error.message };
+    }
+  }
+};
+
+// actions/index.ts
+var farcasterActions = [sendCastAction, replyCastAction];
+
+// utils/config.ts
+var import_core3 = require("@elizaos/core");
+var import_zod2 = require("zod");
+function getProcessEnv() {
+  if (typeof process === "undefined") {
+    return {};
+  }
+  return process.env;
+}
+var env = getProcessEnv();
+function safeParseInt(value, defaultValue) {
+  if (!value)
+    return defaultValue;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isNaN(parsed) ? defaultValue : Math.max(1, parsed);
+}
+function getFarcasterFid(runtime) {
+  const fidStr = runtime.getSetting("FARCASTER_FID");
+  if (!fidStr)
+    return null;
+  const fid = Number.parseInt(fidStr, 10);
+  return Number.isNaN(fid) ? null : fid;
+}
+function hasFarcasterEnabled(runtime) {
+  const fid = runtime.getSetting("FARCASTER_FID");
+  const signerUuid = runtime.getSetting("FARCASTER_SIGNER_UUID");
+  const apiKey = runtime.getSetting("FARCASTER_NEYNAR_API_KEY");
+  runtime.logger.debug(`[hasFarcasterEnabled] FID: ${fid ? "Found" : "Missing"}`);
+  runtime.logger.debug(`[hasFarcasterEnabled] Signer UUID: ${signerUuid ? "Found" : "Missing"}`);
+  runtime.logger.debug(`[hasFarcasterEnabled] API Key: ${apiKey ? "Found" : "Missing"}`);
+  return !!(fid && signerUuid && apiKey);
+}
+function validateFarcasterConfig(runtime) {
+  const fid = getFarcasterFid(runtime);
+  try {
+    const farcasterConfig = {
+      FARCASTER_DRY_RUN: runtime.getSetting("FARCASTER_DRY_RUN") || import_core3.parseBooleanFromText(env.FARCASTER_DRY_RUN || "false"),
+      FARCASTER_FID: fid ?? undefined,
+      MAX_CAST_LENGTH: safeParseInt(runtime.getSetting("MAX_CAST_LENGTH"), DEFAULT_MAX_CAST_LENGTH),
+      FARCASTER_POLL_INTERVAL: safeParseInt(runtime.getSetting("FARCASTER_POLL_INTERVAL"), DEFAULT_POLL_INTERVAL),
+      ENABLE_CAST: runtime.getSetting("ENABLE_CAST") || import_core3.parseBooleanFromText(env.ENABLE_CAST || "true"),
+      CAST_INTERVAL_MIN: safeParseInt(runtime.getSetting("CAST_INTERVAL_MIN"), DEFAULT_CAST_INTERVAL_MIN),
+      CAST_INTERVAL_MAX: safeParseInt(runtime.getSetting("CAST_INTERVAL_MAX"), DEFAULT_CAST_INTERVAL_MAX),
+      ENABLE_ACTION_PROCESSING: runtime.getSetting("ENABLE_ACTION_PROCESSING") || import_core3.parseBooleanFromText(env.ENABLE_ACTION_PROCESSING || "false"),
+      ACTION_INTERVAL: safeParseInt(runtime.getSetting("ACTION_INTERVAL"), 5),
+      CAST_IMMEDIATELY: runtime.getSetting("CAST_IMMEDIATELY") || import_core3.parseBooleanFromText(env.CAST_IMMEDIATELY || "false"),
+      MAX_ACTIONS_PROCESSING: safeParseInt(runtime.getSetting("MAX_ACTIONS_PROCESSING"), 1),
+      FARCASTER_SIGNER_UUID: runtime.getSetting("FARCASTER_SIGNER_UUID"),
+      FARCASTER_NEYNAR_API_KEY: runtime.getSetting("FARCASTER_NEYNAR_API_KEY"),
+      FARCASTER_HUB_URL: runtime.getSetting("FARCASTER_HUB_URL") || "hub.pinata.cloud",
+      FARCASTER_MODE: runtime.getSetting("FARCASTER_MODE") || "polling"
+    };
+    runtime.logger.debug(`[validateFarcasterConfig] Resolved FID: ${farcasterConfig.FARCASTER_FID}`);
+    runtime.logger.debug(`[validateFarcasterConfig] Resolved Signer UUID: ${farcasterConfig.FARCASTER_SIGNER_UUID ? "Found" : "Missing"}`);
+    runtime.logger.debug(`[validateFarcasterConfig] Resolved API Key: ${farcasterConfig.FARCASTER_NEYNAR_API_KEY ? "Found" : "Missing"}`);
+    const config = FarcasterConfigSchema.parse(farcasterConfig);
+    const isDryRun = config.FARCASTER_DRY_RUN;
+    runtime.logger.info("Farcaster Client Configuration:");
+    runtime.logger.info(`- FID: ${config.FARCASTER_FID}`);
+    runtime.logger.info(`- Dry Run Mode: ${isDryRun ? "enabled" : "disabled"}`);
+    runtime.logger.info(`- Enable Cast: ${config.ENABLE_CAST ? "enabled" : "disabled"}`);
+    if (config.ENABLE_CAST) {
+      runtime.logger.info(`- Cast Interval: ${config.CAST_INTERVAL_MIN}-${config.CAST_INTERVAL_MAX} minutes`);
+      runtime.logger.info(`- Cast Immediately: ${config.CAST_IMMEDIATELY ? "enabled" : "disabled"}`);
+    }
+    runtime.logger.info(`- Action Processing: ${config.ENABLE_ACTION_PROCESSING ? "enabled" : "disabled"}`);
+    runtime.logger.info(`- Action Interval: ${config.ACTION_INTERVAL} minutes`);
+    if (isDryRun) {
+      runtime.logger.info("Farcaster client initialized in dry run mode - no actual casts should be posted");
+    }
+    return config;
+  } catch (error) {
+    if (error instanceof import_zod2.z.ZodError) {
+      const errorMessages = error.issues.map((err) => `${err.path.join(".")}: ${err.message}`).join(`
+`);
+      throw new Error(`Farcaster configuration validation failed:
+${errorMessages}`);
+    }
+    throw error;
+  }
+}
+
+// providers/profileProvider.ts
+var spec3 = requireProviderSpec("profileProvider");
+var farcasterProfileProvider = {
+  name: spec3.name,
+  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 = getFarcasterFid(runtime);
+      if (!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 }
+      };
+    }
+  }
+};
+
+// providers/threadProvider.ts
+var formatTimestamp = (timestamp) => {
+  return new Date(timestamp).toLocaleString("en-US", {
+    hour: "2-digit",
+    minute: "2-digit",
+    month: "short",
+    day: "numeric"
+  });
+};
+var spec4 = requireProviderSpec("threadProvider");
+var farcasterThreadProvider = {
+  name: spec4.name,
+  description: "Provides thread context for Farcaster casts so the agent can reference the full conversation.",
+  get: async (runtime, message, _state) => {
+    const contentForSource = message.content;
+    const source = typeof contentForSource.source === "string" ? contentForSource.source : undefined;
+    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 contentMetadata = typeof content.metadata === "object" && content.metadata !== null && !Array.isArray(content.metadata) ? content.metadata : undefined;
+    const castHash = content.hash || content.castHash || contentMetadata?.castHash || messageMetadata.castHash || contentMetadata?.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 ?? "" : ""
+      }
+    };
+  }
+};
+
+// providers/timelineProvider.ts
+function getTimeAgo(date) {
+  const seconds = Math.floor((Date.now() - 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 spec5 = requireProviderSpec("timelineProvider");
+var farcasterTimelineProvider = {
+  name: spec5.name,
+  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,
+          castCount: casts.length
+        },
+        values: {
+          latestCastHash: String(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"
+        }
+      };
+    }
+  }
+};
+
+// providers/index.ts
+var farcasterProviders = [
+  farcasterProfileProvider,
+  farcasterTimelineProvider,
+  farcasterThreadProvider
+];
+
+// 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?.interactions) {
+            if (agentManager.interactions.mode === "webhook") {
+              await agentManager.interactions.processWebhookData?.(webhookData);
+            }
+          }
+        }
+        res.status(200).json({
+          success: true,
+          message: "Webhook processed successfully",
+          event_type: eventType,
+          timestamp: new Date().toISOString()
+        });
+      } catch (error) {
+        if (runtime.logger) {
+          runtime.logger.error(error instanceof Error ? error : new Error(String(error)), "Webhook processing error");
+        }
+        res.status(500).json({
+          success: false,
+          error: "Internal server error"
+        });
+      }
+    }
+  }
+];
+
+// services/FarcasterService.ts
+var import_core11 = require("@elizaos/core");
+
+// managers/AgentManager.ts
+var import_nodejs_sdk2 = require("@neynar/nodejs-sdk");
+
+// client/FarcasterClient.ts
+var import_core5 = require("@elizaos/core");
+var import_nodejs_sdk = require("@neynar/nodejs-sdk");
+var import_lru_cache = require("lru-cache");
+
+// utils/index.ts
+var import_core4 = require("@elizaos/core");
+var MAX_CAST_LENGTH = 1024;
+function castId({ hash, agentId }) {
+  return `${hash}-${agentId}`;
+}
+function castUuid(props) {
+  return import_core4.stringToUuid(castId(props));
+}
+function splitPostContent(content, maxLength = MAX_CAST_LENGTH) {
+  const paragraphs = content.split(`
+
+`).map((p) => p.trim());
+  const posts = [];
+  let currentCast = "";
+  for (const paragraph of paragraphs) {
+    if (!paragraph)
+      continue;
+    if (`${currentCast}
+
+${paragraph}`.trim().length <= maxLength) {
+      if (currentCast) {
+        currentCast += `
+
+${paragraph}`;
+      } else {
+        currentCast = paragraph;
+      }
+    } else {
+      if (currentCast) {
+        posts.push(currentCast.trim());
+      }
+      if (paragraph.length <= maxLength) {
+        currentCast = paragraph;
+      } else {
+        const chunks = splitParagraph(paragraph, maxLength);
+        posts.push(...chunks.slice(0, -1));
+        currentCast = chunks[chunks.length - 1];
+      }
+    }
+  }
+  if (currentCast) {
+    posts.push(currentCast.trim());
+  }
+  return posts;
+}
+function splitParagraph(paragraph, maxLength) {
+  const sentences = paragraph.match(/[^.!?]+[.!?]+|[^.!?]+$/g) || [paragraph];
+  const chunks = [];
+  let currentChunk = "";
+  for (const sentence of sentences) {
+    if (`${currentChunk} ${sentence}`.trim().length <= maxLength) {
+      if (currentChunk) {
+        currentChunk += ` ${sentence}`;
+      } else {
+        currentChunk = sentence;
+      }
+    } else {
+      if (currentChunk) {
+        chunks.push(currentChunk.trim());
+      }
+      if (sentence.length <= maxLength) {
+        currentChunk = sentence;
+      } else {
+        const words = sentence.split(" ");
+        currentChunk = "";
+        for (const word of words) {
+          if (`${currentChunk} ${word}`.trim().length <= maxLength) {
+            if (currentChunk) {
+              currentChunk += ` ${word}`;
+            } else {
+              currentChunk = word;
+            }
+          } else {
+            if (currentChunk) {
+              chunks.push(currentChunk.trim());
+            }
+            currentChunk = word;
+          }
+        }
+      }
+    }
+  }
+  if (currentChunk) {
+    chunks.push(currentChunk.trim());
+  }
+  return chunks;
+}
+function lastCastCacheKey(fid) {
+  return `farcaster/${fid}/lastCast`;
+}
+function neynarCastToCast(neynarCast) {
+  return {
+    hash: neynarCast.hash,
+    authorFid: neynarCast.author.fid,
+    text: neynarCast.text,
+    threadId: neynarCast.thread_hash ?? undefined,
+    profile: {
+      fid: neynarCast.author.fid,
+      name: neynarCast.author.display_name || "anon",
+      username: neynarCast.author.username
+    },
+    ...neynarCast.parent_hash && neynarCast.parent_author?.fid ? {
+      inReplyTo: {
+        hash: neynarCast.parent_hash,
+        fid: neynarCast.parent_author.fid
+      }
+    } : {},
+    timestamp: new Date(neynarCast.timestamp),
+    embeds: neynarCast.embeds && neynarCast.embeds.length > 0 ? neynarCast.embeds : undefined
+  };
+}
+function createCastMemory({
+  roomId,
+  senderId,
+  runtime,
+  cast
+}) {
+  const inReplyTo = cast.inReplyTo ? castUuid({
+    hash: cast.inReplyTo.hash,
+    agentId: runtime.agentId
+  }) : undefined;
+  return {
+    id: castUuid({
+      hash: cast.hash,
+      agentId: runtime.agentId
+    }),
+    agentId: runtime.agentId,
+    entityId: senderId,
+    content: {
+      text: cast.text,
+      source: FARCASTER_SOURCE,
+      url: "",
+      inReplyTo,
+      hash: cast.hash,
+      threadId: cast.threadId,
+      attachments: cast.media && cast.media.length > 0 ? cast.media : undefined
+    },
+    roomId
+  };
+}
+
+// client/FarcasterClient.ts
+var castCache = new import_lru_cache.LRUCache({
+  max: DEFAULT_CAST_CACHE_SIZE,
+  ttl: DEFAULT_CAST_CACHE_TTL
+});
+var profileCache = new import_lru_cache.LRUCache({
+  max: 1000,
+  ttl: 1000 * 60 * 15
+});
+
+class FarcasterClient {
+  neynar;
+  signerUuid;
+  constructor(opts) {
+    this.neynar = opts.neynar;
+    this.signerUuid = opts.signerUuid;
+  }
+  async sendCast({
+    content,
+    inReplyTo
+  }) {
+    const text = (content.text ?? "").trim();
+    if (text.length === 0) {
+      return [];
+    }
+    const chunks = splitPostContent(text);
+    const sent = [];
+    for (const chunk of chunks) {
+      const result = await this.publishCast(chunk, inReplyTo);
+      sent.push(result);
+    }
+    return sent;
+  }
+  async publishCast(cast, parentCastId) {
+    try {
+      const result = await this.neynar.publishCast({
+        signerUuid: this.signerUuid,
+        text: cast,
+        parent: parentCastId?.hash
+      });
+      if (result.success) {
+        return this.getCast(result.cast.hash);
+      }
+      throw new Error(`[Farcaster] Error publishing [${cast}] parentCastId: [${parentCastId}]`);
+    } catch (err) {
+      if (import_nodejs_sdk.isApiErrorResponse(err)) {
+        import_core5.elizaLogger.error(`Neynar error: ${JSON.stringify(err.response.data)}`);
+        throw err.response.data;
+      } else {
+        import_core5.elizaLogger.error(`Error: ${JSON.stringify(err)}`);
+        throw err;
+      }
+    }
+  }
+  async getCast(castHash) {
+    const cachedCast = castCache.get(castHash);
+    if (cachedCast) {
+      return cachedCast;
+    }
+    const response = await this.neynar.lookupCastByHashOrUrl({
+      identifier: castHash,
+      type: "hash"
+    });
+    castCache.set(castHash, response.cast);
+    return response.cast;
+  }
+  async getMentions(request) {
+    const neynarMentionsResponse = await this.neynar.fetchAllNotifications({
+      fid: request.fid,
+      type: ["mentions", "replies"],
+      limit: request.pageSize
+    });
+    const mentions = [];
+    for (const notification of neynarMentionsResponse.notifications) {
+      const neynarCast = notification.cast;
+      if (neynarCast) {
+        mentions.push(neynarCast);
+      }
+    }
+    return mentions;
+  }
+  async getProfile(fid) {
+    if (profileCache.has(fid)) {
+      return profileCache.get(fid);
+    }
+    try {
+      const result = await this.neynar.fetchBulkUsers({ fids: [fid] });
+      if (!result.users || result.users.length < 1) {
+        import_core5.elizaLogger.error("Error fetching user by fid");
+        throw new Error("Profile fetch failed");
+      }
+      const neynarUserProfile = result.users[0];
+      const profile = {
+        fid,
+        name: "",
+        username: ""
+      };
+      profile.name = neynarUserProfile.display_name ?? "";
+      profile.username = neynarUserProfile.username;
+      profile.bio = neynarUserProfile.profile.bio.text;
+      profile.pfp = neynarUserProfile.pfp_url;
+      profileCache.set(fid, profile);
+      return profile;
+    } catch (error) {
+      import_core5.elizaLogger.error(`Error fetching profile: ${JSON.stringify(error)}`);
+      throw error;
+    }
+  }
+  async getTimeline(request) {
+    const timeline = [];
+    const response = await this.neynar.fetchCastsForUser({
+      fid: request.fid,
+      limit: request.pageSize
+    });
+    for (const cast of response.casts) {
+      castCache.set(cast.hash, cast);
+      timeline.push(neynarCastToCast(cast));
+    }
+    const nextCursor = response.next?.cursor ?? undefined;
+    return {
+      timeline,
+      cursor: nextCursor
+    };
+  }
+  clearCache() {
+    profileCache.clear();
+    castCache.clear();
+  }
+  async publishReaction(params) {
+    try {
+      const result = await this.neynar.publishReaction({
+        signerUuid: this.signerUuid,
+        reactionType: params.reactionType,
+        target: params.target
+      });
+      return { success: result.success ?? false };
+    } catch (err) {
+      if (import_nodejs_sdk.isApiErrorResponse(err)) {
+        import_core5.elizaLogger.error(`Neynar error publishing reaction: ${JSON.stringify(err.response.data)}`);
+        throw err.response.data;
+      }
+      import_core5.elizaLogger.error(`Error publishing reaction: ${JSON.stringify(err)}`);
+      throw err;
+    }
+  }
+  async deleteReaction(params) {
+    try {
+      const result = await this.neynar.deleteReaction({
+        signerUuid: this.signerUuid,
+        reactionType: params.reactionType,
+        target: params.target
+      });
+      return { success: result.success ?? false };
+    } catch (err) {
+      if (import_nodejs_sdk.isApiErrorResponse(err)) {
+        import_core5.elizaLogger.error(`Neynar error deleting reaction: ${JSON.stringify(err.response.data)}`);
+        throw err.response.data;
+      }
+      import_core5.elizaLogger.error(`Error deleting reaction: ${JSON.stringify(err)}`);
+      throw err;
+    }
+  }
+}
+
+// managers/CastManager.ts
+var import_core6 = require("@elizaos/core");
+
+// utils/callbacks.ts
+function standardCastHandlerCallback({
+  client,
+  runtime,
+  config,
+  roomId,
+  onCompletion,
+  onError,
+  inReplyTo
+}) {
+  const callback = async (content) => {
+    try {
+      if (config.FARCASTER_DRY_RUN) {
+        runtime.logger.info(`[Farcaster] Dry run: would have cast: ${content.text}`);
+        return [];
+      }
+      const casts = await client.sendCast({ content, inReplyTo });
+      if (casts.length === 0) {
+        runtime.logger.warn("[Farcaster] No casts posted");
+        return [];
+      }
+      const memories = [];
+      for (let i = 0;i < casts.length; i++) {
+        const cast = casts[i];
+        runtime.logger.success(`[Farcaster] Published cast ${cast.hash}`);
+        const memory = createCastMemory({
+          roomId,
+          senderId: runtime.agentId,
+          runtime,
+          cast: neynarCastToCast(cast)
+        });
+        if (i === 0) {
+          memory.content.actions = content.actions;
+        }
+        await runtime.createMemory(memory, "messages");
+        memories.push(memory);
+      }
+      if (onCompletion) {
+        await onCompletion(casts, memories);
+      }
+      return memories;
+    } catch (error) {
+      runtime.logger.error("[Farcaster] Error posting cast:", typeof error === "string" ? error : error.message);
+      if (onError) {
+        await onError(error);
+      }
+      return [];
+    }
+  };
+  return callback;
+}
+
+// managers/CastManager.ts
+class FarcasterCastManager {
+  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;
+    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) => {
+          const timeoutId = setTimeout(resolve, delay);
+          this.timeout = timeoutId;
+        });
+      } 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 = import_core6.createUniqueUuid(this.runtime, this.fid.toString());
+      const roomId = import_core6.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()
+          });
+        }
+      });
+      await this.runtime.emitEvent(import_core6.EventType.POST_GENERATED, {
+        runtime: this.runtime,
+        callback,
+        worldId,
+        userId: this.runtime.agentId,
+        roomId,
+        source: FARCASTER_SOURCE
+      });
+      await this.runtime.emitEvent("FARCASTER_CAST_GENERATED" /* CAST_GENERATED */, {
+        runtime: this.runtime,
+        source: FARCASTER_SOURCE
+      });
+    } catch (error) {
+      this.runtime.logger.error({ error }, "[Farcaster] Error generating new cast");
+    }
+  }
+}
+
+// managers/InteractionManager.ts
+var import_core8 = require("@elizaos/core");
+
+// utils/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 {} 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();
+      }
+    }
+  }
+}
+
+// managers/EmbedManager.ts
+var import_core7 = require("@elizaos/core");
+function isEmbedUrl(embed) {
+  return "url" in embed && typeof embed.url === "string";
+}
+function isEmbedCast(embed) {
+  return "cast" in embed && typeof embed.cast === "object";
+}
+function getMediaTypeFromUrl(url, contentType) {
+  const lowerUrl = url.toLowerCase();
+  const lowerContentType = contentType?.toLowerCase() || "";
+  if (lowerContentType.startsWith("image/"))
+    return "image";
+  if (lowerContentType.startsWith("video/"))
+    return "video";
+  if (lowerContentType.startsWith("audio/"))
+    return "audio";
+  const imageExtensions = [".jpg", ".jpeg", ".png", ".gif", ".webp", ".svg", ".bmp", ".ico"];
+  const videoExtensions = [".mp4", ".webm", ".mov", ".avi", ".mkv", ".m4v"];
+  const audioExtensions = [".mp3", ".wav", ".ogg", ".flac", ".aac", ".m4a"];
+  if (imageExtensions.some((ext) => lowerUrl.includes(ext)))
+    return "image";
+  if (videoExtensions.some((ext) => lowerUrl.includes(ext)))
+    return "video";
+  if (audioExtensions.some((ext) => lowerUrl.includes(ext)))
+    return "audio";
+  return "webpage";
+}
+
+class EmbedManager {
+  runtime;
+  embedCache = new Map;
+  constructor(runtime) {
+    this.runtime = runtime;
+  }
+  async processEmbeds(embeds) {
+    if (embeds.length === 0) {
+      return [];
+    }
+    this.runtime.logger.info({ embedCount: embeds.length }, "[EmbedManager] Processing embeds from cast");
+    const processedMedia = [];
+    for (const embed of embeds) {
+      try {
+        const processed = await this.processEmbed(embed);
+        if (processed) {
+          processedMedia.push(this.toMedia(processed));
+        }
+      } catch (error) {
+        this.runtime.logger.warn({ error: error instanceof Error ? error.message : String(error) }, "[EmbedManager] Failed to process embed");
+      }
+    }
+    this.runtime.logger.info({
+      processedCount: processedMedia.length,
+      types: processedMedia.map((m) => m.source)
+    }, "[EmbedManager] Finished processing embeds");
+    return processedMedia;
+  }
+  async processEmbed(embed) {
+    if (isEmbedUrl(embed)) {
+      return this.processUrlEmbed(embed);
+    } else if (isEmbedCast(embed)) {
+      return this.processCastEmbed(embed);
+    }
+    this.runtime.logger.debug("[EmbedManager] Unknown embed type");
+    return null;
+  }
+  async processUrlEmbed(embed) {
+    const { url, metadata } = embed;
+    const embedId = `embed-${this.hashUrl(url)}`;
+    const cached = this.embedCache.get(embedId);
+    if (cached) {
+      return cached;
+    }
+    const contentType = metadata?.content_type;
+    const mediaType = getMediaTypeFromUrl(url, contentType);
+    if (metadata?.frame) {
+      return this.processFrameEmbed(embed, embedId);
+    }
+    let processed;
+    switch (mediaType) {
+      case "image":
+        processed = await this.processImageEmbed(embed, embedId);
+        break;
+      case "video":
+        processed = await this.processVideoEmbed(embed, embedId);
+        break;
+      case "audio":
+        processed = await this.processAudioEmbed(embed, embedId);
+        break;
+      default:
+        processed = await this.processWebpageEmbed(embed, embedId);
+    }
+    this.embedCache.set(embedId, processed);
+    return processed;
+  }
+  async processImageEmbed(embed, embedId) {
+    const { url, metadata } = embed;
+    let description = "An image attachment";
+    let title = "Image";
+    try {
+      const result = await this.runtime.useModel(import_core7.ModelType.IMAGE_DESCRIPTION, {
+        prompt: "Analyze this image and provide a concise title and description. Focus on the main subject and any notable details.",
+        imageUrl: url
+      });
+      if (result && typeof result === "object") {
+        const typedResult = result;
+        description = typedResult.description || description;
+        title = typedResult.title || title;
+      } else if (typeof result === "string") {
+        description = result;
+      }
+      this.runtime.logger.info({
+        url: `${url.substring(0, 60)}...`,
+        descriptionLength: description.length,
+        title
+      }, "[EmbedManager] Processed image with vision model");
+    } catch (error) {
+      this.runtime.logger.warn({ url, error: error instanceof Error ? error.message : String(error) }, "[EmbedManager] Failed to describe image, using fallback");
+    }
+    return {
+      id: embedId,
+      url,
+      type: "image",
+      title,
+      description,
+      text: description,
+      source: "Farcaster",
+      metadata: {
+        width: metadata?.image?.width_px,
+        height: metadata?.image?.height_px,
+        contentType: metadata?.content_type || "image/*"
+      }
+    };
+  }
+  async processVideoEmbed(embed, embedId) {
+    const { url, metadata } = embed;
+    const description = metadata?.video?.duration_s ? `Video (${Math.round(metadata.video.duration_s)}s)` : "Video attachment";
+    return {
+      id: embedId,
+      url,
+      type: "video",
+      title: "Video",
+      description,
+      text: description,
+      source: "Farcaster",
+      metadata: {
+        duration: metadata?.video?.duration_s,
+        contentType: metadata?.content_type || "video/*"
+      }
+    };
+  }
+  async processAudioEmbed(embed, embedId) {
+    const { url, metadata } = embed;
+    const description = "Audio attachment";
+    return {
+      id: embedId,
+      url,
+      type: "audio",
+      title: "Audio",
+      description,
+      text: description,
+      source: "Farcaster",
+      metadata: {
+        contentType: metadata?.content_type || "audio/*"
+      }
+    };
+  }
+  async processWebpageEmbed(embed, embedId) {
+    const { url, metadata } = embed;
+    const html = metadata?.html;
+    const title = html?.ogTitle || html?.ogSiteName || "Web Page";
+    const hostnameMatch = url.match(/^(?:https?:\/\/)?([^/?#]+)/);
+    const hostname = hostnameMatch ? hostnameMatch[1] : url;
+    const description = html?.ogDescription || `Link to ${hostname}`;
+    return {
+      id: embedId,
+      url,
+      type: "webpage",
+      title,
+      description,
+      text: `${title}: ${description}`,
+      source: "Web",
+      metadata: {
+        contentType: "text/html"
+      }
+    };
+  }
+  async processFrameEmbed(embed, embedId) {
+    const { url, metadata } = embed;
+    const frame = metadata?.frame;
+    const title = frame?.title || "Farcaster Frame";
+    const description = `Interactive Frame: ${title}`;
+    return {
+      id: embedId,
+      url,
+      type: "frame",
+      title,
+      description,
+      text: description,
+      source: "Frame",
+      metadata: {
+        contentType: "application/x-farcaster-frame"
+      }
+    };
+  }
+  async processCastEmbed(embed) {
+    const cast = embed.cast;
+    const embedId = `cast-${cast.hash}`;
+    const cached = this.embedCache.get(embedId);
+    if (cached) {
+      return cached;
+    }
+    const authorUsername = cast.author?.username || "unknown";
+    const title = `Quoted cast from @${authorUsername}`;
+    const description = cast.text || "";
+    const processed = {
+      id: embedId,
+      url: `https://warpcast.com/${authorUsername}/${cast.hash.slice(0, 10)}`,
+      type: "cast",
+      title,
+      description,
+      text: `[Quote from @${authorUsername}]: ${description}`,
+      source: "Farcaster",
+      metadata: {
+        castHash: cast.hash,
+        authorFid: cast.author?.fid,
+        authorUsername
+      }
+    };
+    this.embedCache.set(embedId, processed);
+    return processed;
+  }
+  toMedia(embed) {
+    return {
+      id: embed.id,
+      url: embed.url,
+      title: embed.title || embed.type,
+      source: embed.source,
+      description: embed.description,
+      text: embed.text
+    };
+  }
+  hashUrl(url) {
+    let hash = 0;
+    for (let i = 0;i < url.length; i++) {
+      const char = url.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash).toString(36);
+  }
+  clearCache() {
+    this.embedCache.clear();
+  }
+}
+
+// managers/InteractionSource.ts
+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() {
+    this.runtime.logger.info("Starting Farcaster polling mode");
+    if (this.isRunning) {
+      return;
+    }
+    this.isRunning = true;
+    this.runPeriodically();
+  }
+  async stop() {
+    this.runtime.logger.info("Stopping Farcaster polling mode");
+    if (this.timeout)
+      clearTimeout(this.timeout);
+    this.isRunning = false;
+  }
+  async runPeriodically() {
+    while (this.isRunning) {
+      try {
+        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() {
+    this.runtime.logger.info("Starting Farcaster webhook mode");
+    if (this.isRunning) {
+      return;
+    }
+    this.isRunning = true;
+    this.runtime.logger.info("Webhook source is active - waiting for webhook events");
+  }
+  async stop() {
+    this.runtime.logger.info("Stopping Farcaster webhook mode");
+    this.isRunning = false;
+  }
+  async processWebhookData(webhookData) {
+    if (!this.isRunning) {
+      this.runtime.logger.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);
+    default:
+      return new FarcasterPollingSource(params);
+  }
+}
+
+// managers/InteractionManager.ts
+class FarcasterInteractionManager {
+  client;
+  runtime;
+  config;
+  asyncQueue;
+  embedManager;
+  mode;
+  source;
+  constructor(opts) {
+    this.client = opts.client;
+    this.runtime = opts.runtime;
+    this.config = opts.config;
+    this.asyncQueue = new AsyncQueue(1);
+    this.embedManager = new EmbedManager(opts.runtime);
+    this.mode = opts.config.FARCASTER_MODE;
+    this.source = createFarcasterInteractionSource({
+      client: this.client,
+      runtime: this.runtime,
+      config: this.config,
+      processor: this
+    });
+    this.runtime.logger.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);
+    if (mention.embeds && mention.embeds.length > 0) {
+      try {
+        this.runtime.logger.debug({ castHash: cast.hash, embedCount: mention.embeds.length }, "[Farcaster] Processing embeds for mention");
+        const processedMedia = await this.embedManager.processEmbeds(mention.embeds);
+        mention.media = processedMedia;
+        this.runtime.logger.info({ castHash: cast.hash, mediaCount: processedMedia.length }, "[Farcaster] Processed embeds for mention");
+      } catch (error) {
+        this.runtime.logger.warn({
+          error: error instanceof Error ? error.message : String(error),
+          castHash: cast.hash
+        }, "[Farcaster] Failed to process embeds, continuing without media");
+      }
+    }
+    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);
+    if (reply.embeds && reply.embeds.length > 0) {
+      try {
+        this.runtime.logger.debug({ castHash: cast.hash, embedCount: reply.embeds.length }, "[Farcaster] Processing embeds for reply");
+        const processedMedia = await this.embedManager.processEmbeds(reply.embeds);
+        reply.media = processedMedia;
+        this.runtime.logger.info({ castHash: cast.hash, mediaCount: processedMedia.length }, "[Farcaster] Processed embeds for reply");
+      } catch (error) {
+        this.runtime.logger.warn({
+          error: error instanceof Error ? error.message : String(error),
+          castHash: cast.hash
+        }, "[Farcaster] Failed to process embeds, continuing without media");
+      }
+    }
+    await this.handleMentionCast({ agent, mention: reply, cast });
+  }
+  async processWebhookData(webhookData) {
+    if (webhookData.type !== "cast.created" || !webhookData.data) {
+      this.runtime.logger.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") {
+      this.runtime.logger.warn("Invalid webhook cast data structure - missing author, hash, or author.fid");
+      return;
+    }
+    if (castData.author.fid === agentFid) {
+      this.runtime.logger.debug("Skipping webhook event from agent itself");
+      return;
+    }
+    const memoryId = castUuid({
+      agentId: this.runtime.agentId,
+      hash: castData.hash
+    });
+    if (await this.runtime.getMemoryById(memoryId)) {
+      this.runtime.logger.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 || "";
+      this.runtime.logger.info(`Processing webhook MENTION from @${username}: "${text}"`);
+      try {
+        const neynarCast = await this.client.getCast(castData.hash);
+        await this.processMention(neynarCast);
+      } catch (error) {
+        this.runtime.logger.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 || "";
+      this.runtime.logger.info(`Processing webhook REPLY from @${username}: "${text}"`);
+      try {
+        const neynarCast = await this.client.getCast(castData.hash);
+        await this.processReply(neynarCast);
+      } catch (error) {
+        this.runtime.logger.error({ error }, `Failed to process webhook reply from @${username}:`);
+      }
+    } else {
+      this.runtime.logger.debug("Webhook cast is neither mention nor reply to agent");
+    }
+  }
+  async ensureCastConnection(cast) {
+    return await this.asyncQueue.submit(async () => {
+      const memoryId = castUuid({
+        agentId: this.runtime.agentId,
+        hash: cast.hash
+      });
+      const conversationId = cast.threadId ?? cast.inReplyTo?.hash ?? cast.hash;
+      const entityId = import_core8.createUniqueUuid(this.runtime, cast.authorFid.toString());
+      const worldId = import_core8.createUniqueUuid(this.runtime, cast.authorFid.toString());
+      const roomId = import_core8.createUniqueUuid(this.runtime, conversationId);
+      if (entityId !== this.runtime.agentId) {
+        await this.runtime.ensureConnection({
+          entityId,
+          roomId,
+          worldName: `${cast.profile.username}'s Farcaster`,
+          userName: cast.profile.username,
+          name: cast.profile.name,
+          source: FARCASTER_SOURCE,
+          type: import_core8.ChannelType.THREAD,
+          channelId: conversationId,
+          messageServerId: import_core8.stringToUuid(cast.authorFid.toString()),
+          worldId,
+          metadata: {
+            ownership: { ownerId: cast.authorFid.toString() },
+            farcaster: {
+              username: cast.profile.username,
+              id: cast.authorFid.toString(),
+              name: cast.profile.name
+            }
+          }
+        });
+      }
+      let text = cast.text;
+      if (cast.media && cast.media.length > 0) {
+        const attachmentTypes = cast.media.map((m) => m.source || "attachment").join(", ");
+        text = `${cast.text}
+
+(Attachments: ${cast.media.length} - ${attachmentTypes})`;
+      }
+      const memory = {
+        id: memoryId,
+        agentId: this.runtime.agentId,
+        content: {
+          text,
+          inReplyTo: cast.inReplyTo?.hash ? castUuid({
+            agentId: this.runtime.agentId,
+            hash: cast.inReplyTo.hash
+          }) : undefined,
+          source: FARCASTER_SOURCE,
+          channelType: import_core8.ChannelType.THREAD,
+          attachments: cast.media && cast.media.length > 0 ? cast.media : undefined
+        },
+        entityId,
+        roomId,
+        createdAt: cast.timestamp.getTime()
+      };
+      return memory;
+    });
+  }
+  async buildThreadForCast(cast, skipMemoryId) {
+    const thread = [];
+    const visited = new Set;
+    const client = this.client;
+    const runtime = this.runtime;
+    const self = this;
+    async function processThread(currentCast) {
+      const memoryId = castUuid({
+        hash: currentCast.hash,
+        agentId: runtime.agentId
+      });
+      if (visited.has(currentCast.hash) || skipMemoryId.has(memoryId)) {
+        return;
+      }
+      visited.add(currentCast.hash);
+      const memory = await runtime.getMemoryById(memoryId);
+      if (!memory) {
+        runtime.logger.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: newMemory,
+          cast: currentCast,
+          source: FARCASTER_SOURCE
+        });
+      }
+      thread.unshift(currentCast);
+      if (currentCast.inReplyTo) {
+        const parentCast = await client.getCast(currentCast.inReplyTo.hash);
+        await processThread(neynarCastToCast(parentCast));
+      }
+    }
+    await processThread(cast);
+    return thread;
+  }
+  async handleMentionCast({
+    agent,
+    mention,
+    cast
+  }) {
+    if (mention.profile.fid === agent.fid) {
+      this.runtime.logger.info({ hash: mention.hash }, "skipping cast from bot itself");
+      return;
+    }
+    const memory = await this.ensureCastConnection(mention);
+    await this.buildThreadForCast(mention, memory.id ? new Set([memory.id]) : new Set);
+    if (!memory.content.text || memory.content.text.trim() === "") {
+      this.runtime.logger.info({ hash: mention.hash }, "skipping cast with no text");
+      return;
+    }
+    const callback = standardCastHandlerCallback({
+      client: this.client,
+      runtime: this.runtime,
+      config: this.config,
+      roomId: memory.roomId,
+      inReplyTo: {
+        hash: mention.hash,
+        fid: mention.authorFid
+      }
+    });
+    try {
+      if (!this.runtime.messageService) {
+        this.runtime.logger.warn("[Farcaster] messageService not available, skipping mention handling");
+        return;
+      }
+      await this.runtime.messageService.handleMessage(this.runtime, memory, callback);
+    } catch (error) {
+      this.runtime.logger.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
+    };
+    this.runtime.emitEvent("FARCASTER_MENTION_RECEIVED" /* MENTION_RECEIVED */, mentionPayload);
+  }
+  async start() {
+    this.runtime.logger.info(`Starting Farcaster interaction manager in ${this.mode} mode`);
+    await this.source.start();
+  }
+  async stop() {
+    this.runtime.logger.info("Stopping Farcaster interaction manager");
+    await this.source.stop();
+  }
+}
+
+// managers/AgentManager.ts
+class FarcasterAgentManager {
+  runtime;
+  client;
+  casts;
+  interactions;
+  constructor(runtime, config) {
+    this.runtime = runtime;
+    const signerUuid = config.FARCASTER_SIGNER_UUID;
+    const neynarConfig = new import_nodejs_sdk2.Configuration({
+      apiKey: config.FARCASTER_NEYNAR_API_KEY
+    });
+    const neynar = new import_nodejs_sdk2.NeynarAPIClient(neynarConfig);
+    const client = new FarcasterClient({ neynar, signerUuid });
+    this.client = client;
+    runtime.logger.success("Farcaster Neynar client initialized.");
+    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()]);
+  }
+  async stop() {
+    await Promise.all([this.casts.stop(), this.interactions.stop()]);
+  }
+}
+
+// services/CastService.ts
+var import_core9 = require("@elizaos/core");
+class FarcasterCastService {
+  client;
+  runtime;
+  static serviceType = "ICastService";
+  constructor(client, runtime) {
+    this.client = client;
+    this.runtime = runtime;
+  }
+  async getCasts(params) {
+    try {
+      const fid = getFarcasterFid(this.runtime);
+      if (!fid) {
+        this.runtime.logger.error("FARCASTER_FID is not configured");
+        return [];
+      }
+      const { timeline } = await this.client.getTimeline({
+        fid,
+        pageSize: params.limit || 50
+      });
+      return timeline.map((cast) => this.castToFarcasterCast(cast, params.agentId));
+    } catch (error) {
+      this.runtime.logger.error(`Failed to get casts: ${JSON.stringify({ params, error })}`);
+      return [];
+    }
+  }
+  async createCast(params) {
+    try {
+      let castText = params.text;
+      if (!castText || castText.trim() === "") {
+        castText = await this.generateCastContent();
+      }
+      if (castText.length > 320) {
+        castText = await this.truncateCast(castText);
+      }
+      const casts = await this.client.sendCast({
+        content: { text: castText },
+        inReplyTo: params.replyTo ? { hash: params.replyTo.hash, fid: params.replyTo.fid } : undefined
+      });
+      if (casts.length === 0) {
+        throw new Error("No cast was created");
+      }
+      const cast = neynarCastToCast(casts[0]);
+      const farcasterCast = {
+        id: castUuid({ hash: cast.hash, agentId: params.agentId }),
+        agentId: params.agentId,
+        roomId: params.roomId,
+        userId: cast.profile.fid.toString(),
+        username: cast.profile.username,
+        text: cast.text,
+        timestamp: cast.timestamp.getTime(),
+        inReplyTo: params.replyTo?.hash,
+        media: [],
+        metadata: {
+          castHash: cast.hash,
+          authorFid: cast.authorFid,
+          source: FARCASTER_SOURCE,
+          ...cast.threadId ? { threadId: cast.threadId } : {}
+        }
+      };
+      await this.storeCastInMemory(params.roomId, farcasterCast);
+      return farcasterCast;
+    } catch (error) {
+      this.runtime.logger.error(`Failed to create cast: ${JSON.stringify({ params, error })}`);
+      throw error;
+    }
+  }
+  async deleteCast(params) {
+    this.runtime.logger.warn(`Cast deletion is not supported by the Farcaster API: ${JSON.stringify({ castHash: params.castHash })}`);
+  }
+  async likeCast(params) {
+    try {
+      const result = await this.client.publishReaction({
+        reactionType: "like",
+        target: params.castHash
+      });
+      if (!result.success) {
+        throw new Error(`Failed to like cast: ${params.castHash}`);
+      }
+      this.runtime.logger.info(`Liked cast: ${params.castHash}`);
+    } catch (error) {
+      this.runtime.logger.error(`Failed to like cast: ${JSON.stringify({ params, error })}`);
+      throw error;
+    }
+  }
+  async unlikeCast(params) {
+    try {
+      const result = await this.client.deleteReaction({
+        reactionType: "like",
+        target: params.castHash
+      });
+      if (!result.success) {
+        throw new Error(`Failed to unlike cast: ${params.castHash}`);
+      }
+      this.runtime.logger.info(`Unliked cast: ${params.castHash}`);
+    } catch (error) {
+      this.runtime.logger.error(`Failed to unlike cast: ${JSON.stringify({ params, error })}`);
+      throw error;
+    }
+  }
+  async recast(params) {
+    try {
+      const result = await this.client.publishReaction({
+        reactionType: "recast",
+        target: params.castHash
+      });
+      if (!result.success) {
+        throw new Error(`Failed to recast: ${params.castHash}`);
+      }
+      this.runtime.logger.info(`Recasted: ${params.castHash}`);
+    } catch (error) {
+      this.runtime.logger.error(`Failed to recast: ${JSON.stringify({ params, error })}`);
+      throw error;
+    }
+  }
+  async unrecast(params) {
+    try {
+      const result = await this.client.deleteReaction({
+        reactionType: "recast",
+        target: params.castHash
+      });
+      if (!result.success) {
+        throw new Error(`Failed to remove recast: ${params.castHash}`);
+      }
+      this.runtime.logger.info(`Removed recast: ${params.castHash}`);
+    } catch (error) {
+      this.runtime.logger.error(`Failed to remove recast: ${JSON.stringify({ params, error })}`);
+      throw error;
+    }
+  }
+  async getMentions(params) {
+    try {
+      const fid = getFarcasterFid(this.runtime);
+      if (!fid) {
+        this.runtime.logger.error("FARCASTER_FID is not configured");
+        return [];
+      }
+      const mentions = await this.client.getMentions({
+        fid,
+        pageSize: params.limit || 20
+      });
+      return mentions.map((castWithInteractions) => {
+        const cast = neynarCastToCast(castWithInteractions);
+        return this.castToFarcasterCast(cast, params.agentId);
+      });
+    } catch (error) {
+      this.runtime.logger.error(`Failed to get mentions: ${JSON.stringify({ params, error })}`);
+      return [];
+    }
+  }
+  async generateCastContent() {
+    const prompt = `Generate an interesting and engaging Farcaster cast. It should be conversational, authentic, and under 320 characters. Topics can include technology, AI, crypto, decentralized social media, or general observations about life.`;
+    try {
+      const response = await this.runtime.useModel(import_core9.ModelType.TEXT_SMALL, {
+        prompt,
+        maxTokens: 100
+      });
+      return response;
+    } catch (error) {
+      this.runtime.logger.error(`Failed to generate cast content: ${JSON.stringify({ error })}`);
+      return "Hello Farcaster! \uD83D\uDC4B";
+    }
+  }
+  async truncateCast(text) {
+    const prompt = `Shorten this text to under 320 characters while keeping the main message intact: "${text}"`;
+    try {
+      const response = await this.runtime.useModel(import_core9.ModelType.TEXT_SMALL, {
+        prompt,
+        maxTokens: 100
+      });
+      const truncated = response;
+      if (truncated.length > 320) {
+        return `${truncated.substring(0, 317)}...`;
+      }
+      return truncated;
+    } catch (error) {
+      this.runtime.logger.error(`Failed to truncate cast: ${JSON.stringify({ error })}`);
+      return `${text.substring(0, 317)}...`;
+    }
+  }
+  async storeCastInMemory(roomId, cast) {
+    try {
+      const entityId = import_core9.createUniqueUuid(this.runtime, cast.userId);
+      const memory = {
+        id: import_core9.createUniqueUuid(this.runtime, cast.id),
+        agentId: this.runtime.agentId,
+        entityId,
+        content: {
+          text: cast.text,
+          castHash: String(cast.metadata?.castHash || ""),
+          castId: cast.id,
+          author: cast.username,
+          timestamp: cast.timestamp
+        },
+        roomId,
+        createdAt: Date.now()
+      };
+      await this.runtime.createMemory(memory, "farcaster_casts");
+    } catch (error) {
+      this.runtime.logger.error(`Failed to store cast in memory: ${JSON.stringify({ error })}`);
+    }
+  }
+  castToFarcasterCast(cast, agentId) {
+    return {
+      id: castUuid({ hash: cast.hash, agentId }),
+      agentId,
+      roomId: import_core9.createUniqueUuid(this.runtime, cast.threadId || cast.hash),
+      userId: cast.profile.fid.toString(),
+      username: cast.profile.username,
+      text: cast.text,
+      timestamp: cast.timestamp.getTime(),
+      media: [],
+      metadata: {
+        castHash: cast.hash,
+        authorFid: cast.authorFid,
+        source: FARCASTER_SOURCE,
+        ...cast.threadId ? { threadId: cast.threadId } : {},
+        ...cast.stats ? {
+          recasts: cast.stats.recasts,
+          replies: cast.stats.replies,
+          likes: cast.stats.likes
+        } : {}
+      }
+    };
+  }
+}
+
+// services/MessageService.ts
+var import_core10 = require("@elizaos/core");
+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: import_core10.createUniqueUuid(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 { agentId, roomId, limit = 20 } = options;
+      const fid = getFarcasterFid(this.runtime);
+      if (!fid) {
+        this.runtime.logger.error("[Farcaster] FARCASTER_FID is not configured");
+        return [];
+      }
+      const { timeline } = await this.client.getTimeline({
+        fid,
+        pageSize: limit
+      });
+      const messages = timeline.map((cast) => this.castToMessage(cast, agentId)).filter((message) => {
+        if (roomId) {
+          return message.roomId === roomId;
+        }
+        return true;
+      });
+      return messages;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.runtime.logger.error(err, "[Farcaster] Error fetching messages");
+      return [];
+    }
+  }
+  async sendMessage(options) {
+    try {
+      const { text, type, roomId, replyToId, agentId } = options;
+      let inReplyTo;
+      if (replyToId && type === "REPLY" /* REPLY */) {
+        const parentHash = typeof options.metadata?.parentHash === "string" ? options.metadata.parentHash : replyToId;
+        const fid = getFarcasterFid(this.runtime);
+        if (!fid) {
+          throw new Error("FARCASTER_FID is not configured");
+        }
+        inReplyTo = {
+          hash: parentHash,
+          fid
+        };
+      }
+      const casts = await this.client.sendCast({
+        content: { text },
+        inReplyTo
+      });
+      if (casts.length === 0) {
+        throw new Error("No cast was created");
+      }
+      const cast = neynarCastToCast(casts[0]);
+      const message = this.castToMessage(cast, agentId, options.metadata);
+      message.roomId = roomId;
+      message.type = type;
+      const castGeneratedPayload = {
+        runtime: this.runtime,
+        source: FARCASTER_SOURCE,
+        castHash: cast.hash,
+        ...cast.threadId ? { threadId: cast.threadId } : {},
+        messageId: message.id,
+        roomId
+      };
+      await this.runtime.emitEvent("FARCASTER_CAST_GENERATED" /* CAST_GENERATED */, castGeneratedPayload);
+      return message;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.runtime.logger.error(err, "[Farcaster] Error sending message");
+      throw err;
+    }
+  }
+  async deleteMessage(_messageId, _agentId) {
+    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);
+      return this.castToMessage(farcasterCast, agentId);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.runtime.logger.error(err, "[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) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.runtime.logger.error(err, "[Farcaster] Error fetching thread");
+      return [];
+    }
+  }
+  async markAsRead(_messageIds, _agentId) {
+    this.runtime.logger.debug("[Farcaster] Mark as read is not applicable for Farcaster casts");
+  }
+}
+
+// services/FarcasterService.ts
+class FarcasterService extends import_core11.Service {
+  static instance;
+  managers = new Map;
+  messageServices = new Map;
+  castServices = new Map;
+  static serviceType = FARCASTER_SERVICE_NAME;
+  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;
+    }
+    return FarcasterService.instance;
+  }
+  async initialize(runtime) {
+    await FarcasterService.start(runtime);
+  }
+  static async start(runtime) {
+    const service = FarcasterService.getInstance();
+    let manager = service.managers.get(runtime.agentId);
+    if (manager) {
+      runtime.logger.warn({ agentId: runtime.agentId }, "Farcaster service already started");
+      return service;
+    }
+    if (!hasFarcasterEnabled(runtime)) {
+      runtime.logger.debug({ agentId: runtime.agentId }, "Farcaster service not enabled");
+      return service;
+    }
+    const farcasterConfig = validateFarcasterConfig(runtime);
+    manager = new FarcasterAgentManager(runtime, farcasterConfig);
+    service.managers.set(runtime.agentId, manager);
+    const messageService = new FarcasterMessageService(manager.client, runtime);
+    const castService = new FarcasterCastService(manager.client, runtime);
+    service.messageServices.set(runtime.agentId, messageService);
+    service.castServices.set(runtime.agentId, castService);
+    await manager.start();
+    runtime.logger.success({ agentId: runtime.agentId }, "Farcaster client started");
+    return service;
+  }
+  static async stop(runtime) {
+    const service = FarcasterService.getInstance();
+    const 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);
+      runtime.logger.info({ agentId: runtime.agentId }, "Farcaster client stopped");
+    } else {
+      runtime.logger.debug({ agentId: runtime.agentId }, "Farcaster service not running");
+    }
+  }
+  async stop() {
+    for (const manager of Array.from(this.managers.values())) {
+      const agentId = manager.runtime.agentId;
+      manager.runtime.logger.debug("Stopping Farcaster service");
+      try {
+        await FarcasterService.stop(manager.runtime);
+      } catch (error) {
+        manager.runtime.logger.error({ agentId, error }, "Error stopping Farcaster service");
+      }
+    }
+  }
+  getMessageService(agentId) {
+    return this.messageServices.get(agentId);
+  }
+  getCastService(agentId) {
+    return this.castServices.get(agentId);
+  }
+  async healthCheck() {
+    const managerStatuses = {};
+    let overallHealthy = true;
+    for (const [agentId, manager] of Array.from(this.managers.entries())) {
+      try {
+        const fid = getFarcasterFid(manager.runtime);
+        if (!fid) {
+          throw new Error("FARCASTER_FID not configured");
+        }
+        const profile = await manager.client.getProfile(fid);
+        managerStatuses[agentId] = {
+          status: "healthy",
+          fid: profile.fid,
+          username: profile.username
+        };
+      } catch (error) {
+        managerStatuses[agentId] = {
+          status: "unhealthy",
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+        overallHealthy = false;
+      }
+    }
+    return {
+      healthy: overallHealthy,
+      details: {
+        activeManagers: this.managers.size,
+        managerStatuses
+      }
+    };
+  }
+  getActiveManagers() {
+    return new Map(this.managers);
+  }
+}
+
+// index.ts
+var farcasterPlugin = {
+  name: "farcaster",
+  description: "Farcaster client plugin for sending and receiving casts",
+  services: [FarcasterService],
+  actions: farcasterActions,
+  providers: farcasterProviders,
+  routes: farcasterWebhookRoutes
+};
+var typescript_default = farcasterPlugin;
+
+//# debugId=AB1623D783FDBC2864756E2164756E21