@elizaos/plugin-farcaster 2.0.3-beta.5 → 2.0.3-beta.7

package/dist/node/index.node.js

@@ -0,0 +1,2546 @@
+// index.ts
+import { getConnectorAccountManager, logger } from "@elizaos/core";
+
+// utils/config.ts
+import { parseBooleanFromText } from "@elizaos/core";
+import { z as z3 } from "zod";
+
+// types/index.ts
+import * as zod from "zod";
+var z2 = zod.z;
+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 = z2.object({
+  FARCASTER_DRY_RUN: z2.union([z2.boolean(), z2.string()]).transform((val) => typeof val === "string" ? val.toLowerCase() === "true" : val),
+  FARCASTER_FID: z2.number().int().min(1, "Farcaster fid is required"),
+  MAX_CAST_LENGTH: z2.number().int().default(DEFAULT_MAX_CAST_LENGTH),
+  FARCASTER_POLL_INTERVAL: z2.number().int().default(DEFAULT_POLL_INTERVAL),
+  FARCASTER_MODE: z2.enum(["polling", "webhook"]).default("polling"),
+  ENABLE_CAST: z2.union([z2.boolean(), z2.string()]).transform((val) => typeof val === "string" ? val.toLowerCase() === "true" : val),
+  CAST_INTERVAL_MIN: z2.number().int(),
+  CAST_INTERVAL_MAX: z2.number().int(),
+  ENABLE_ACTION_PROCESSING: z2.union([z2.boolean(), z2.string()]).transform((val) => typeof val === "string" ? val.toLowerCase() === "true" : val),
+  ACTION_INTERVAL: z2.number().int(),
+  CAST_IMMEDIATELY: z2.union([z2.boolean(), z2.string()]).transform((val) => typeof val === "string" ? val.toLowerCase() === "true" : val),
+  MAX_ACTIONS_PROCESSING: z2.number().int(),
+  FARCASTER_SIGNER_UUID: z2.string().min(1, "FARCASTER_SIGNER_UUID is not set"),
+  FARCASTER_NEYNAR_API_KEY: z2.string().min(1, "FARCASTER_NEYNAR_API_KEY is not set"),
+  FARCASTER_HUB_URL: z2.string().min(1, "FARCASTER_HUB_URL is not set")
+});
+var FARCASTER_SERVICE_NAME = "farcaster";
+var FARCASTER_SOURCE = "farcaster";
+
+// utils/config.ts
+var DEFAULT_FARCASTER_ACCOUNT_ID = "default";
+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 stringSetting(runtime, key) {
+  const value = runtime.getSetting(key);
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function characterConfig(runtime) {
+  const settings = runtime.character.settings;
+  const raw = settings?.farcaster;
+  return raw && typeof raw === "object" ? raw : {};
+}
+function parseAccountsJson(runtime) {
+  const raw = stringSetting(runtime, "FARCASTER_ACCOUNTS");
+  if (!raw)
+    return {};
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) {
+      return Object.fromEntries(parsed.filter((item) => Boolean(item) && typeof item === "object").map((item) => [normalizeFarcasterAccountId(item.accountId ?? item.id), item]));
+    }
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function allAccountConfigs(runtime) {
+  return {
+    ...characterConfig(runtime).accounts ?? {},
+    ...parseAccountsJson(runtime)
+  };
+}
+function accountConfig(runtime, accountId) {
+  const accounts = allAccountConfigs(runtime);
+  return accounts[accountId] ?? accounts[normalizeFarcasterAccountId(accountId)] ?? {};
+}
+function rawField(record, keys) {
+  if (!record)
+    return;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim())
+      return value.trim();
+    if (typeof value === "number" || typeof value === "boolean")
+      return String(value);
+  }
+  return;
+}
+function normalizeFarcasterAccountId(accountId) {
+  if (typeof accountId !== "string")
+    return DEFAULT_FARCASTER_ACCOUNT_ID;
+  const trimmed = accountId.trim();
+  return trimmed || DEFAULT_FARCASTER_ACCOUNT_ID;
+}
+function listFarcasterAccountIds(runtime) {
+  const ids = new Set;
+  const config = characterConfig(runtime);
+  if (stringSetting(runtime, "FARCASTER_FID") || config.FARCASTER_FID && config.FARCASTER_SIGNER_UUID) {
+    ids.add(DEFAULT_FARCASTER_ACCOUNT_ID);
+  }
+  for (const id of Object.keys(allAccountConfigs(runtime))) {
+    ids.add(normalizeFarcasterAccountId(id));
+  }
+  return Array.from(ids.size ? ids : new Set([DEFAULT_FARCASTER_ACCOUNT_ID])).sort((a, b) => a.localeCompare(b));
+}
+function resolveDefaultFarcasterAccountId(runtime) {
+  const requested = stringSetting(runtime, "FARCASTER_DEFAULT_ACCOUNT_ID") ?? stringSetting(runtime, "FARCASTER_ACCOUNT_ID");
+  if (requested)
+    return normalizeFarcasterAccountId(requested);
+  const ids = listFarcasterAccountIds(runtime);
+  return ids.includes(DEFAULT_FARCASTER_ACCOUNT_ID) ? DEFAULT_FARCASTER_ACCOUNT_ID : ids[0];
+}
+function readFarcasterAccountId(...sources) {
+  for (const source of sources) {
+    if (!source || typeof source !== "object")
+      continue;
+    const record = source;
+    const parameters = record.parameters && typeof record.parameters === "object" ? record.parameters : {};
+    const data = record.data && typeof record.data === "object" ? record.data : {};
+    const metadata = record.metadata && typeof record.metadata === "object" ? record.metadata : {};
+    const farcaster = data.farcaster && typeof data.farcaster === "object" ? data.farcaster : {};
+    const value = record.accountId ?? parameters.accountId ?? data.accountId ?? farcaster.accountId ?? metadata.accountId;
+    if (typeof value === "string" && value.trim())
+      return normalizeFarcasterAccountId(value);
+  }
+  return;
+}
+function getFarcasterFid(runtime, accountId) {
+  const normalizedAccountId = normalizeFarcasterAccountId(accountId ?? resolveDefaultFarcasterAccountId(runtime));
+  const account = accountConfig(runtime, normalizedAccountId);
+  const base = characterConfig(runtime);
+  const allowEnv = normalizedAccountId === DEFAULT_FARCASTER_ACCOUNT_ID;
+  const fidStr = rawField(account, ["FARCASTER_FID", "fid"]) ?? rawField(base, ["FARCASTER_FID", "fid"]) ?? (allowEnv ? stringSetting(runtime, "FARCASTER_FID") : undefined);
+  if (!fidStr)
+    return null;
+  const fid = Number.parseInt(fidStr, 10);
+  return Number.isNaN(fid) ? null : fid;
+}
+function hasFarcasterEnabled(runtime, accountId) {
+  const normalizedAccountId = normalizeFarcasterAccountId(accountId ?? resolveDefaultFarcasterAccountId(runtime));
+  const account = accountConfig(runtime, normalizedAccountId);
+  const base = characterConfig(runtime);
+  const allowEnv = normalizedAccountId === DEFAULT_FARCASTER_ACCOUNT_ID;
+  const fid = getFarcasterFid(runtime, normalizedAccountId);
+  const signerUuid = rawField(account, ["FARCASTER_SIGNER_UUID", "signerUuid"]) ?? rawField(base, ["FARCASTER_SIGNER_UUID", "signerUuid"]) ?? (allowEnv ? stringSetting(runtime, "FARCASTER_SIGNER_UUID") : undefined);
+  const apiKey = rawField(account, ["FARCASTER_NEYNAR_API_KEY", "neynarApiKey", "apiKey"]) ?? rawField(base, ["FARCASTER_NEYNAR_API_KEY", "neynarApiKey", "apiKey"]) ?? (allowEnv ? stringSetting(runtime, "FARCASTER_NEYNAR_API_KEY") : undefined);
+  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, accountId) {
+  const normalizedAccountId = normalizeFarcasterAccountId(accountId ?? resolveDefaultFarcasterAccountId(runtime));
+  const account = accountConfig(runtime, normalizedAccountId);
+  const base = characterConfig(runtime);
+  const allowEnv = normalizedAccountId === DEFAULT_FARCASTER_ACCOUNT_ID;
+  const field = (keys, envKey) => rawField(account, keys) ?? rawField(base, keys) ?? (allowEnv && envKey ? stringSetting(runtime, envKey) : undefined);
+  const fid = getFarcasterFid(runtime, normalizedAccountId);
+  try {
+    const farcasterConfig = {
+      FARCASTER_DRY_RUN: field(["FARCASTER_DRY_RUN", "dryRun"], "FARCASTER_DRY_RUN") || parseBooleanFromText(env.FARCASTER_DRY_RUN || "false"),
+      FARCASTER_FID: fid ?? undefined,
+      MAX_CAST_LENGTH: safeParseInt(field(["MAX_CAST_LENGTH", "maxCastLength"], "MAX_CAST_LENGTH"), DEFAULT_MAX_CAST_LENGTH),
+      FARCASTER_POLL_INTERVAL: safeParseInt(field(["FARCASTER_POLL_INTERVAL", "pollInterval"], "FARCASTER_POLL_INTERVAL"), DEFAULT_POLL_INTERVAL),
+      ENABLE_CAST: field(["ENABLE_CAST", "enableCast"], "ENABLE_CAST") || parseBooleanFromText(env.ENABLE_CAST || "true"),
+      CAST_INTERVAL_MIN: safeParseInt(field(["CAST_INTERVAL_MIN", "castIntervalMin"], "CAST_INTERVAL_MIN"), DEFAULT_CAST_INTERVAL_MIN),
+      CAST_INTERVAL_MAX: safeParseInt(field(["CAST_INTERVAL_MAX", "castIntervalMax"], "CAST_INTERVAL_MAX"), DEFAULT_CAST_INTERVAL_MAX),
+      ENABLE_ACTION_PROCESSING: field(["ENABLE_ACTION_PROCESSING", "enableActionProcessing"], "ENABLE_ACTION_PROCESSING") || parseBooleanFromText(env.ENABLE_ACTION_PROCESSING || "false"),
+      ACTION_INTERVAL: safeParseInt(field(["ACTION_INTERVAL", "actionInterval"], "ACTION_INTERVAL"), 5),
+      CAST_IMMEDIATELY: field(["CAST_IMMEDIATELY", "castImmediately"], "CAST_IMMEDIATELY") || parseBooleanFromText(env.CAST_IMMEDIATELY || "false"),
+      MAX_ACTIONS_PROCESSING: safeParseInt(field(["MAX_ACTIONS_PROCESSING", "maxActionsProcessing"], "MAX_ACTIONS_PROCESSING"), 1),
+      FARCASTER_SIGNER_UUID: field(["FARCASTER_SIGNER_UUID", "signerUuid"], "FARCASTER_SIGNER_UUID"),
+      FARCASTER_NEYNAR_API_KEY: field(["FARCASTER_NEYNAR_API_KEY", "neynarApiKey", "apiKey"], "FARCASTER_NEYNAR_API_KEY"),
+      FARCASTER_HUB_URL: field(["FARCASTER_HUB_URL", "hubUrl"], "FARCASTER_HUB_URL") || "hub.pinata.cloud",
+      FARCASTER_MODE: field(["FARCASTER_MODE", "mode"], "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, accountId: normalizedAccountId };
+  } catch (error) {
+    if (error instanceof z3.ZodError) {
+      const errorMessages = error.issues.map((err) => `${err.path.join(".")}: ${err.message}`).join(`
+`);
+      throw new Error(`Farcaster configuration validation failed:
+${errorMessages}`);
+    }
+    throw error;
+  }
+}
+
+// connector-account-provider.ts
+var FARCASTER_PROVIDER_ID = "farcaster";
+function toConnectorAccount(runtime, accountId) {
+  let connected = false;
+  let fid;
+  let hubUrl = "";
+  try {
+    const config = validateFarcasterConfig(runtime, accountId);
+    fid = config.FARCASTER_FID;
+    hubUrl = config.FARCASTER_HUB_URL;
+    connected = Boolean(fid && config.FARCASTER_SIGNER_UUID && config.FARCASTER_NEYNAR_API_KEY);
+  } catch {
+    connected = false;
+  }
+  const now = Date.now();
+  return {
+    id: accountId,
+    provider: FARCASTER_PROVIDER_ID,
+    label: fid ? `FID ${fid}` : accountId,
+    role: "OWNER",
+    purpose: ["posting", "reading"],
+    accessGate: "open",
+    status: connected ? "connected" : "disabled",
+    externalId: fid ? String(fid) : undefined,
+    displayHandle: fid ? String(fid) : undefined,
+    createdAt: now,
+    updatedAt: now,
+    metadata: {
+      hubUrl,
+      fid
+    }
+  };
+}
+function createFarcasterConnectorAccountProvider(runtime) {
+  return {
+    provider: FARCASTER_PROVIDER_ID,
+    label: "Farcaster",
+    listAccounts: async (_manager) => {
+      const ids = listFarcasterAccountIds(runtime);
+      return ids.map((id) => toConnectorAccount(runtime, id));
+    },
+    createAccount: async (input, _manager) => {
+      return {
+        ...input,
+        provider: FARCASTER_PROVIDER_ID,
+        role: input.role ?? "OWNER",
+        purpose: input.purpose ?? ["posting", "reading"],
+        accessGate: input.accessGate ?? "open",
+        status: input.status ?? "pending"
+      };
+    },
+    patchAccount: async (_accountId, patch, _manager) => {
+      return { ...patch, provider: FARCASTER_PROVIDER_ID };
+    },
+    deleteAccount: async (_accountId, _manager) => {}
+  };
+}
+
+// generated/specs/specs.ts
+var coreActionsSpec = {
+  version: "1.0.0",
+  actions: []
+};
+var allActionsSpec = {
+  version: "1.0.0",
+  actions: []
+};
+var coreProvidersSpec = {
+  version: "1.0.0",
+  providers: [
+    {
+      name: "farcasterProfile",
+      description: "Provides information about the agent",
+      dynamic: true
+    }
+  ]
+};
+var allProvidersSpec = {
+  version: "1.0.0",
+  providers: [
+    {
+      name: "farcasterProfile",
+      description: "Provides information about the agent",
+      dynamic: true
+    }
+  ]
+};
+var coreActionDocs = coreActionsSpec.actions;
+var allActionDocs = allActionsSpec.actions;
+var coreProviderDocs = coreProvidersSpec.providers;
+var allProviderDocs = allProvidersSpec.providers;
+
+// 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]));
+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;
+}
+
+// providers/profileProvider.ts
+var spec = requireProviderSpec("farcasterProfile");
+var MAX_PROFILE_FIELD_LENGTH = 280;
+function truncateProfileField(value) {
+  return value ? value.slice(0, MAX_PROFILE_FIELD_LENGTH) : value;
+}
+var farcasterProfileProvider = {
+  name: spec.name,
+  description: "Provides information about the agent's Farcaster profile",
+  descriptionCompressed: "provide information agent Farcaster profile",
+  dynamic: true,
+  contexts: ["social_posting", "messaging", "connectors"],
+  contextGate: { anyOf: ["social_posting", "messaging", "connectors"] },
+  cacheStable: false,
+  cacheScope: "turn",
+  get: async (runtime, message, state) => {
+    try {
+      const service = runtime.getService(FARCASTER_SERVICE_NAME);
+      const accountId = readFarcasterAccountId(message, state);
+      const manager = service.getManagerForAccount(accountId, runtime.agentId) ?? service.getManagerForAccount(undefined, runtime.agentId);
+      if (!manager) {
+        runtime.logger.debug("[FarcasterProfileProvider] No managers available");
+        return {
+          text: "Farcaster profile not available.",
+          data: { available: false }
+        };
+      }
+      const selectedAccountId = manager.config.accountId;
+      const fid = getFarcasterFid(runtime, selectedAccountId);
+      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);
+        const username = truncateProfileField(profile.username) ?? "";
+        const name = truncateProfileField(profile.name);
+        return {
+          text: `Your Farcaster profile: @${username} (FID: ${profile.fid}). ${name ? `Display name: ${name}` : ""}`,
+          data: {
+            available: true,
+            fid: profile.fid,
+            username,
+            name,
+            pfp: profile.pfp,
+            accountId: selectedAccountId
+          },
+          values: {
+            fid: profile.fid,
+            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/index.ts
+var farcasterProviders = [farcasterProfileProvider];
+
+// routes/webhook.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isPositiveSafeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isNeynarWebhookData(value) {
+  if (!isRecord(value) || !isNonEmptyString(value.type))
+    return false;
+  if (value.data === undefined)
+    return true;
+  if (!isRecord(value.data))
+    return false;
+  if (!isNonEmptyString(value.data.hash))
+    return false;
+  if (!isRecord(value.data.author) || !isPositiveSafeInteger(value.data.author.fid))
+    return false;
+  if (value.data.text !== undefined && typeof value.data.text !== "string") {
+    return false;
+  }
+  if (value.data.mentioned_profiles !== undefined && !(Array.isArray(value.data.mentioned_profiles) && value.data.mentioned_profiles.every((profile) => isRecord(profile) && isPositiveSafeInteger(profile.fid)))) {
+    return false;
+  }
+  if (value.data.parent_hash !== undefined && !isNonEmptyString(value.data.parent_hash)) {
+    return false;
+  }
+  if (value.data.parent_author !== undefined && !(isRecord(value.data.parent_author) && isPositiveSafeInteger(value.data.parent_author.fid))) {
+    return false;
+  }
+  return true;
+}
+var farcasterWebhookRoutes = [
+  {
+    type: "POST",
+    name: "Farcaster Webhook Handler",
+    path: "/webhook",
+    handler: async (req, res, runtime) => {
+      try {
+        if (!isNeynarWebhookData(req.body)) {
+          res.status(400).json({
+            success: false,
+            error: "Invalid webhook payload"
+          });
+          return;
+        }
+        const webhookData = req.body;
+        const eventType = webhookData.type;
+        const farcasterService = runtime.getService(FARCASTER_SERVICE_NAME);
+        const accountId = readFarcasterAccountId(webhookData);
+        if (farcasterService && accountId) {
+          const manager = farcasterService.getManagerForAccount?.(accountId, runtime.agentId);
+          if (manager?.interactions.mode === "webhook") {
+            await manager.interactions.processWebhookData(webhookData);
+          }
+        } else if (farcasterService) {
+          const managers = farcasterService.getManagersForAgent?.(runtime.agentId) ?? new Map;
+          await Promise.all(Array.from(managers.values()).filter((manager) => manager.interactions.mode === "webhook").map((manager) => manager.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
+import {
+  ChannelType as ChannelType3,
+  Service
+} from "@elizaos/core";
+
+// managers/AgentManager.ts
+import { Configuration, NeynarAPIClient } from "@neynar/nodejs-sdk";
+
+// client/FarcasterClient.ts
+import { logger as elizaLogger } from "@elizaos/core";
+import { isApiErrorResponse } from "@neynar/nodejs-sdk";
+import { LRUCache } from "lru-cache";
+
+// utils/index.ts
+import { stringToUuid } from "@elizaos/core";
+var MAX_CAST_LENGTH = 1024;
+function extractCastEmbedUrls(content) {
+  return Array.isArray(content.attachments) ? content.attachments.map((m) => m?.url).filter((u) => typeof u === "string" && u.trim().length > 0) : [];
+}
+function castId({ hash, agentId }) {
+  return `${hash}-${agentId}`;
+}
+function castUuid(props) {
+  return 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,
+  accountId
+}) {
+  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,
+      ...accountId ? { accountId } : {},
+      url: "",
+      inReplyTo,
+      hash: cast.hash,
+      threadId: cast.threadId,
+      attachments: cast.media && cast.media.length > 0 ? cast.media : undefined
+    },
+    metadata: {
+      ...accountId ? { accountId } : {}
+    },
+    roomId
+  };
+}
+
+// client/FarcasterClient.ts
+async function logNeynarCall(op, context, fn) {
+  const startedAt = Date.now();
+  elizaLogger.debug({ sdk: "neynar", op, ...context }, `[FarcasterClient] ${op} started`);
+  try {
+    const result = await fn();
+    elizaLogger.info({
+      sdk: "neynar",
+      op,
+      ...context,
+      durationMs: Date.now() - startedAt
+    }, `[FarcasterClient] ${op} ok`);
+    return result;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    elizaLogger.warn({
+      sdk: "neynar",
+      op,
+      ...context,
+      durationMs: Date.now() - startedAt,
+      error: message
+    }, `[FarcasterClient] ${op} failed`);
+    throw error;
+  }
+}
+var castCache = new LRUCache({
+  max: DEFAULT_CAST_CACHE_SIZE,
+  ttl: DEFAULT_CAST_CACHE_TTL
+});
+var profileCache = new 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,
+    embeds
+  }) {
+    const text = (content.text ?? "").trim();
+    const mediaEmbeds = (embeds ?? []).filter((url) => typeof url === "string" && url.trim().length > 0);
+    if (text.length === 0 && mediaEmbeds.length === 0) {
+      return [];
+    }
+    const chunks = text.length > 0 ? splitPostContent(text) : [""];
+    const sent = [];
+    for (let i = 0;i < chunks.length; i++) {
+      const result = await this.publishCast(chunks[i], inReplyTo, i === 0 ? mediaEmbeds : undefined);
+      sent.push(result);
+    }
+    return sent;
+  }
+  async publishCast(cast, parentCastId, embeds) {
+    try {
+      const result = await logNeynarCall("publishCast", {
+        textLen: cast.length,
+        parentHash: parentCastId?.hash ?? null,
+        embedCount: embeds?.length ?? 0
+      }, async () => this.neynar.publishCast({
+        signerUuid: this.signerUuid,
+        text: cast,
+        parent: parentCastId?.hash,
+        ...embeds && embeds.length > 0 ? {
+          embeds: embeds.map((url) => ({ url }))
+        } : {}
+      }));
+      if (result.success) {
+        return this.getCast(result.cast.hash);
+      }
+      throw new Error(`[Farcaster] Error publishing [${cast}] parentCastId: [${parentCastId}]`);
+    } catch (err) {
+      if (isApiErrorResponse(err)) {
+        elizaLogger.error(`Neynar error: ${JSON.stringify(err.response.data)}`);
+        throw err.response.data;
+      } else {
+        throw err;
+      }
+    }
+  }
+  async getCast(castHash) {
+    const cachedCast = castCache.get(castHash);
+    if (cachedCast) {
+      return cachedCast;
+    }
+    const response = await logNeynarCall("lookupCastByHashOrUrl", { castHash }, async () => this.neynar.lookupCastByHashOrUrl({
+      identifier: castHash,
+      type: "hash"
+    }));
+    castCache.set(castHash, response.cast);
+    return response.cast;
+  }
+  async getMentions(request) {
+    const neynarMentionsResponse = await logNeynarCall("fetchAllNotifications", { fid: request.fid, pageSize: request.pageSize }, async () => 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);
+    }
+    const result = await logNeynarCall("fetchBulkUsers", { fid }, async () => this.neynar.fetchBulkUsers({ fids: [fid] }));
+    if (result.users.length < 1) {
+      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;
+    const bioText = neynarUserProfile.profile.bio.text;
+    if (bioText != null) {
+      profile.bio = bioText;
+    }
+    const profileImageUrl = neynarUserProfile.pfp_url;
+    if (profileImageUrl != null) {
+      profile.pfp = profileImageUrl;
+    }
+    profileCache.set(fid, profile);
+    return profile;
+  }
+  async getTimeline(request) {
+    const timeline = [];
+    const response = await logNeynarCall("fetchCastsForUser", { fid: request.fid, pageSize: request.pageSize }, async () => 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 logNeynarCall("publishReaction", { reactionType: params.reactionType, target: params.target }, async () => this.neynar.publishReaction({
+        signerUuid: this.signerUuid,
+        reactionType: params.reactionType,
+        target: params.target
+      }));
+      return { success: result.success ?? false };
+    } catch (err) {
+      if (isApiErrorResponse(err)) {
+        elizaLogger.error(`Neynar error publishing reaction: ${JSON.stringify(err.response.data)}`);
+        throw err.response.data;
+      }
+      throw err;
+    }
+  }
+  async deleteReaction(params) {
+    try {
+      const result = await logNeynarCall("deleteReaction", { reactionType: params.reactionType, target: params.target }, async () => this.neynar.deleteReaction({
+        signerUuid: this.signerUuid,
+        reactionType: params.reactionType,
+        target: params.target
+      }));
+      return { success: result.success ?? false };
+    } catch (err) {
+      if (isApiErrorResponse(err)) {
+        elizaLogger.error(`Neynar error deleting reaction: ${JSON.stringify(err.response.data)}`);
+        throw err.response.data;
+      }
+      throw err;
+    }
+  }
+}
+
+// managers/CastManager.ts
+import {
+  createUniqueUuid,
+  EventType,
+  setTrajectoryPurpose,
+  withStandaloneTrajectory
+} from "@elizaos/core";
+
+// utils/callbacks.ts
+function standardCastHandlerCallback({
+  client,
+  runtime,
+  config,
+  roomId,
+  onCompletion,
+  onError,
+  inReplyTo
+}) {
+  const callback = async (content) => {
+    try {
+      const accountId = normalizeFarcasterAccountId(config.accountId ?? DEFAULT_FARCASTER_ACCOUNT_ID);
+      if (config.FARCASTER_DRY_RUN) {
+        runtime.logger.info(`[Farcaster] Dry run: would have cast: ${content.text}`);
+        return [];
+      }
+      const casts = await client.sendCast({
+        content,
+        inReplyTo,
+        embeds: extractCastEmbedUrls(content)
+      });
+      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),
+          accountId
+        });
+        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;
+  }
+  getAccountId() {
+    return normalizeFarcasterAccountId(this.config.accountId ?? DEFAULT_FARCASTER_ACCOUNT_ID);
+  }
+  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() {
+    await withStandaloneTrajectory(this.runtime, {
+      source: "plugin-farcaster:auto-cast",
+      metadata: {
+        platform: FARCASTER_SOURCE,
+        kind: "public_post_generation",
+        fid: this.fid,
+        accountId: this.getAccountId()
+      }
+    }, async () => {
+      setTrajectoryPurpose("background");
+      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()
+            });
+          }
+        });
+        await this.runtime.emitEvent(EventType.POST_GENERATED, {
+          runtime: this.runtime,
+          callback,
+          worldId,
+          userId: this.runtime.agentId,
+          roomId,
+          source: FARCASTER_SOURCE,
+          accountId: this.getAccountId()
+        });
+        await this.runtime.emitEvent("FARCASTER_POST_GENERATED" /* POST_GENERATED */, {
+          runtime: this.runtime,
+          source: FARCASTER_SOURCE,
+          accountId: this.getAccountId()
+        });
+      } catch (error) {
+        this.runtime.logger.error({ error }, "[Farcaster] Error generating new cast");
+      }
+    });
+  }
+}
+
+// managers/InteractionManager.ts
+import {
+  ChannelType,
+  createUniqueUuid as createUniqueUuid2,
+  stringToUuid as stringToUuid2
+} from "@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
+import { ModelType, withStandaloneTrajectory as withStandaloneTrajectory2 } from "@elizaos/core";
+function isEmbedUrl(embed) {
+  return "url" in embed;
+}
+function isEmbedCast(embed) {
+  return "cast" in embed;
+}
+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 withStandaloneTrajectory2(this.runtime, { source: "farcaster-embed" }, async () => this.runtime.useModel(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}`);
+  }
+  getAccountId() {
+    return normalizeFarcasterAccountId(this.config.accountId ?? DEFAULT_FARCASTER_ACCOUNT_ID);
+  }
+  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 = 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,
+          roomId,
+          worldName: `${cast.profile.username}'s Farcaster`,
+          userName: cast.profile.username,
+          name: cast.profile.name,
+          source: FARCASTER_SOURCE,
+          type: ChannelType.THREAD,
+          channelId: conversationId,
+          messageServerId: stringToUuid2(cast.authorFid.toString()),
+          worldId,
+          metadata: {
+            accountId: this.getAccountId(),
+            ownership: { ownerId: cast.authorFid.toString() },
+            farcaster: {
+              accountId: this.getAccountId(),
+              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,
+          accountId: this.getAccountId(),
+          channelType: ChannelType.THREAD,
+          attachments: cast.media && cast.media.length > 0 ? cast.media : undefined
+        },
+        entityId,
+        roomId,
+        createdAt: cast.timestamp.getTime(),
+        metadata: {
+          accountId: this.getAccountId()
+        }
+      };
+      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,
+          accountId: self.getAccountId()
+        });
+      }
+      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,
+      accountId: this.getAccountId(),
+      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;
+  config;
+  constructor(runtime, config) {
+    this.runtime = runtime;
+    this.config = config;
+    const signerUuid = config.FARCASTER_SIGNER_UUID;
+    const neynarConfig = new Configuration({
+      apiKey: config.FARCASTER_NEYNAR_API_KEY
+    });
+    const neynar = new NeynarAPIClient(neynarConfig);
+    const client = new FarcasterClient({ neynar, signerUuid });
+    this.client = client;
+    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
+import {
+  ChannelType as ChannelType2,
+  createUniqueUuid as createUniqueUuid3,
+  ModelType as ModelType2
+} from "@elizaos/core";
+function clampLimit(value, fallback, max) {
+  if (!Number.isFinite(value)) {
+    return fallback;
+  }
+  return Math.min(Math.max(1, Math.floor(value)), max);
+}
+function readContentString(content, keys) {
+  const record = content;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+  return;
+}
+
+class FarcasterCastService {
+  client;
+  runtime;
+  accountId;
+  static serviceType = "ICastService";
+  constructor(client, runtime, accountId = DEFAULT_FARCASTER_ACCOUNT_ID) {
+    this.client = client;
+    this.runtime = runtime;
+    this.accountId = accountId;
+  }
+  getAccountId() {
+    return normalizeFarcasterAccountId(this.accountId);
+  }
+  async getCasts(params) {
+    try {
+      const fid = getFarcasterFid(this.runtime, this.getAccountId());
+      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;
+      const media = (params.media ?? []).filter((url) => typeof url === "string" && url.trim().length > 0);
+      if ((!castText || castText.trim() === "") && media.length === 0) {
+        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,
+        ...media.length > 0 ? { embeds: media } : {}
+      });
+      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: media.map((url) => ({ url })),
+        metadata: {
+          accountId: this.getAccountId(),
+          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 handleSendPost(runtime, content) {
+    const requestedAccountId = normalizeFarcasterAccountId(readFarcasterAccountId(content) ?? this.getAccountId());
+    if (requestedAccountId !== this.getAccountId()) {
+      throw new Error(`Farcaster account '${requestedAccountId}' is not available in this service instance`);
+    }
+    const text = typeof content.text === "string" ? content.text.trim() : "";
+    const media = extractCastEmbedUrls(content);
+    if (!text && media.length === 0) {
+      throw new Error("Farcaster post connector requires non-empty text content or at least one attachment.");
+    }
+    const parentHash = readContentString(content, ["parentHash", "replyTo", "replyToHash"]);
+    const fid = getFarcasterFid(this.runtime, this.getAccountId());
+    const cast = await this.createCast({
+      agentId: runtime.agentId,
+      roomId: createUniqueUuid3(runtime, `farcaster:feed:${fid ?? runtime.agentId}`),
+      text,
+      ...media.length > 0 ? { media } : {},
+      ...parentHash && fid ? { replyTo: { hash: parentHash, fid } } : {}
+    });
+    return this.farcasterCastToMemory(runtime, cast);
+  }
+  async fetchFeed(context, params = {}) {
+    const requestedAccountId = normalizeFarcasterAccountId(context.accountId ?? context.metadata?.accountId ?? this.getAccountId());
+    if (requestedAccountId !== this.getAccountId()) {
+      throw new Error(`Farcaster account '${requestedAccountId}' is not available in this service instance`);
+    }
+    const casts = await this.getCasts({
+      agentId: context.runtime.agentId,
+      limit: clampLimit(params.limit, 25, 100),
+      cursor: params.cursor
+    });
+    return casts.map((cast) => this.farcasterCastToMemory(context.runtime, cast));
+  }
+  async searchPosts(context, params) {
+    const requestedAccountId = normalizeFarcasterAccountId(context.accountId ?? context.metadata?.accountId ?? this.getAccountId());
+    if (requestedAccountId !== this.getAccountId()) {
+      throw new Error(`Farcaster account '${requestedAccountId}' is not available in this service instance`);
+    }
+    const query = params.query.trim().toLowerCase();
+    if (!query) {
+      return [];
+    }
+    const limit = clampLimit(params.limit, 25, 100);
+    const casts = await this.getCasts({
+      agentId: context.runtime.agentId,
+      limit: 100,
+      cursor: params.cursor
+    });
+    return casts.filter((cast) => {
+      const text = cast.text.toLowerCase();
+      const username = cast.username.toLowerCase();
+      return text.includes(query) || username.includes(query);
+    }).slice(0, limit).map((cast) => this.farcasterCastToMemory(context.runtime, cast));
+  }
+  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, this.getAccountId());
+      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(ModelType2.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(ModelType2.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 = createUniqueUuid3(this.runtime, cast.userId);
+      const memory = {
+        id: createUniqueUuid3(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,
+          accountId: this.getAccountId()
+        },
+        metadata: {
+          accountId: this.getAccountId()
+        },
+        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 })}`);
+    }
+  }
+  farcasterCastToMemory(runtime, cast) {
+    const authorId = cast.userId || "unknown";
+    const entityId = authorId === runtime.agentId ? runtime.agentId : createUniqueUuid3(runtime, `farcaster:user:${authorId}`);
+    const roomId = cast.roomId || createUniqueUuid3(runtime, `farcaster:feed:${authorId}`);
+    const castHash = typeof cast.metadata?.castHash === "string" ? cast.metadata.castHash : cast.id;
+    return {
+      id: createUniqueUuid3(runtime, `farcaster:cast:${castHash}`),
+      agentId: runtime.agentId,
+      entityId,
+      roomId,
+      createdAt: cast.timestamp || Date.now(),
+      content: {
+        text: cast.text,
+        source: FARCASTER_SOURCE,
+        channelType: ChannelType2.FEED,
+        ...cast.inReplyTo ? { inReplyTo: createUniqueUuid3(runtime, `farcaster:cast:${cast.inReplyTo}`) } : {}
+      },
+      metadata: {
+        type: "message",
+        source: FARCASTER_SOURCE,
+        accountId: this.getAccountId(),
+        provider: FARCASTER_SOURCE,
+        timestamp: cast.timestamp,
+        fromBot: entityId === runtime.agentId,
+        messageIdFull: castHash,
+        chatType: ChannelType2.FEED,
+        sender: {
+          id: authorId,
+          username: cast.username
+        },
+        farcaster: {
+          accountId: this.getAccountId(),
+          castId: cast.id,
+          castHash,
+          authorFid: cast.metadata?.authorFid,
+          username: cast.username,
+          inReplyTo: cast.inReplyTo,
+          metrics: {
+            recasts: cast.metadata?.recasts,
+            replies: cast.metadata?.replies,
+            likes: cast.metadata?.likes
+          },
+          ...cast.metadata ?? {}
+        }
+      }
+    };
+  }
+  castToFarcasterCast(cast, agentId) {
+    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,
+      timestamp: cast.timestamp.getTime(),
+      media: [],
+      metadata: {
+        castHash: cast.hash,
+        authorFid: cast.authorFid,
+        source: FARCASTER_SOURCE,
+        accountId: this.getAccountId(),
+        ...cast.threadId ? { threadId: cast.threadId } : {},
+        ...cast.stats ? {
+          recasts: cast.stats.recasts,
+          replies: cast.stats.replies,
+          likes: cast.stats.likes
+        } : {}
+      }
+    };
+  }
+}
+
+// services/MessageService.ts
+import { createUniqueUuid as createUniqueUuid4 } from "@elizaos/core";
+class FarcasterMessageService {
+  client;
+  runtime;
+  accountId;
+  constructor(client, runtime, accountId = DEFAULT_FARCASTER_ACCOUNT_ID) {
+    this.client = client;
+    this.runtime = runtime;
+    this.accountId = accountId;
+  }
+  getAccountId() {
+    return normalizeFarcasterAccountId(this.accountId);
+  }
+  castToMessage(cast, agentId, extraMetadata) {
+    return {
+      id: castUuid({ hash: cast.hash, agentId }),
+      agentId,
+      roomId: createUniqueUuid4(this.runtime, cast.threadId || cast.hash),
+      userId: cast.profile.fid.toString(),
+      username: cast.profile.username,
+      text: cast.text,
+      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,
+        accountId: this.getAccountId(),
+        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, this.getAccountId());
+      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 requestedAccountId = normalizeFarcasterAccountId(options.accountId ?? readFarcasterAccountId(options.metadata) ?? this.getAccountId());
+      if (requestedAccountId !== this.getAccountId()) {
+        throw new Error(`Farcaster account '${requestedAccountId}' is not available in this service instance`);
+      }
+      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, this.getAccountId());
+        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 postGeneratedPayload = {
+        runtime: this.runtime,
+        source: FARCASTER_SOURCE,
+        castHash: cast.hash,
+        ...cast.threadId ? { threadId: cast.threadId } : {},
+        messageId: message.id,
+        roomId,
+        accountId: this.getAccountId()
+      };
+      await this.runtime.emitEvent("FARCASTER_POST_GENERATED" /* POST_GENERATED */, postGeneratedPayload);
+      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 Service {
+  static instance;
+  agents = 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();
+    if (service.agents.has(runtime.agentId)) {
+      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 accounts = {
+      defaultAccountId: normalizeFarcasterAccountId(resolveDefaultFarcasterAccountId(runtime)),
+      managers: new Map,
+      messageServices: new Map,
+      castServices: new Map
+    };
+    service.agents.set(runtime.agentId, accounts);
+    for (const accountId of listFarcasterAccountIds(runtime)) {
+      if (!hasFarcasterEnabled(runtime, accountId)) {
+        continue;
+      }
+      const farcasterConfig = validateFarcasterConfig(runtime, accountId);
+      const manager = new FarcasterAgentManager(runtime, farcasterConfig);
+      accounts.managers.set(accountId, manager);
+      accounts.messageServices.set(accountId, new FarcasterMessageService(manager.client, runtime, accountId));
+      accounts.castServices.set(accountId, new FarcasterCastService(manager.client, runtime, accountId));
+      await manager.start();
+      runtime.logger.success({ agentId: runtime.agentId, accountId }, "Farcaster client started");
+    }
+    return service;
+  }
+  static async stop(runtime) {
+    const service = FarcasterService.getInstance();
+    const accounts = service.agents.get(runtime.agentId);
+    if (accounts) {
+      for (const manager of accounts.managers.values()) {
+        await manager.stop();
+      }
+      service.agents.delete(runtime.agentId);
+      runtime.logger.info({ agentId: runtime.agentId }, "Farcaster client stopped");
+    } else {
+      runtime.logger.debug({ agentId: runtime.agentId }, "Farcaster service not running");
+    }
+  }
+  static registerSendHandlers(runtime, serviceInstance) {
+    const accounts = serviceInstance.agents.get(runtime.agentId);
+    if (!accounts || accounts.castServices.size === 0) {
+      runtime.logger.warn({ src: "plugin:farcaster", agentId: runtime.agentId }, "Cannot register Farcaster post connector; cast service is not initialized");
+      return;
+    }
+    const withPostConnector = runtime;
+    if (typeof withPostConnector.registerPostConnector !== "function") {
+      return;
+    }
+    for (const castService of accounts.castServices.values()) {
+      const accountId = castService.getAccountId();
+      withPostConnector.registerPostConnector({
+        source: "farcaster",
+        accountId,
+        label: "Farcaster",
+        description: "Farcaster public cast connector for publishing casts and reading or searching the authenticated account's recent feed.",
+        capabilities: ["post", "fetch_feed", "search_posts"],
+        contexts: ["social", "social_posting", "connectors"],
+        metadata: {
+          accountId,
+          service: FARCASTER_SERVICE_NAME
+        },
+        postHandler: castService.handleSendPost.bind(castService),
+        fetchFeed: castService.fetchFeed.bind(castService),
+        searchPosts: castService.searchPosts.bind(castService),
+        contentShaping: {
+          systemPromptFragment: "For Farcaster casts, write a conversational public cast under 320 characters. If replying, keep enough context for a public thread.",
+          constraints: {
+            maxLength: 320,
+            supportsMarkdown: false,
+            channelType: ChannelType3.FEED
+          }
+        }
+      });
+    }
+    runtime.logger.info({ src: "plugin:farcaster", agentId: runtime.agentId }, "Registered Farcaster post connector");
+  }
+  async stop() {
+    for (const [agentId, accounts] of Array.from(this.agents.entries())) {
+      const runtime = accounts.managers.values().next().value?.runtime;
+      runtime?.logger.debug("Stopping Farcaster service");
+      try {
+        if (runtime) {
+          await FarcasterService.stop(runtime);
+        } else {
+          this.agents.delete(agentId);
+        }
+      } catch (error) {
+        runtime?.logger.error({ agentId, error }, "Error stopping Farcaster service");
+      }
+    }
+  }
+  getMessageService(agentId, accountId) {
+    return this.getMessageServiceForAccount(accountId, agentId);
+  }
+  getCastService(agentId, accountId) {
+    return this.getCastServiceForAccount(accountId, agentId);
+  }
+  getMessageServiceForAccount(accountId, agentId) {
+    const resolvedAgentId = agentId ?? this.firstAgentId();
+    if (!resolvedAgentId)
+      return;
+    const accounts = this.agents.get(resolvedAgentId);
+    if (!accounts)
+      return;
+    const id = accountId ? normalizeFarcasterAccountId(accountId) : accounts.defaultAccountId;
+    return accounts.messageServices.get(id);
+  }
+  getCastServiceForAccount(accountId, agentId) {
+    const resolvedAgentId = agentId ?? this.firstAgentId();
+    if (!resolvedAgentId)
+      return;
+    const accounts = this.agents.get(resolvedAgentId);
+    if (!accounts)
+      return;
+    const id = accountId ? normalizeFarcasterAccountId(accountId) : accounts.defaultAccountId;
+    return accounts.castServices.get(id);
+  }
+  getManagerForAccount(accountId, agentId) {
+    const resolvedAgentId = agentId ?? this.firstAgentId();
+    if (!resolvedAgentId)
+      return;
+    const accounts = this.agents.get(resolvedAgentId);
+    if (!accounts)
+      return;
+    const id = accountId ? normalizeFarcasterAccountId(accountId) : accounts.defaultAccountId;
+    return accounts.managers.get(id);
+  }
+  getDefaultAccountId(agentId) {
+    const resolvedAgentId = agentId ?? this.firstAgentId();
+    return resolvedAgentId ? this.agents.get(resolvedAgentId)?.defaultAccountId : undefined;
+  }
+  listAccountIds(agentId) {
+    const resolvedAgentId = agentId ?? this.firstAgentId();
+    const accounts = resolvedAgentId ? this.agents.get(resolvedAgentId) : undefined;
+    return accounts ? Array.from(accounts.managers.keys()) : [];
+  }
+  getManagersForAgent(agentId) {
+    const resolvedAgentId = agentId ?? this.firstAgentId();
+    const accounts = resolvedAgentId ? this.agents.get(resolvedAgentId) : undefined;
+    return new Map(accounts?.managers ?? []);
+  }
+  async healthCheck() {
+    const managerStatuses = {};
+    let overallHealthy = true;
+    for (const [agentId, accounts] of Array.from(this.agents.entries())) {
+      managerStatuses[agentId] = {};
+      for (const [accountId, manager] of Array.from(accounts.managers.entries())) {
+        try {
+          const fid = getFarcasterFid(manager.runtime, accountId);
+          if (!fid) {
+            throw new Error("FARCASTER_FID not configured");
+          }
+          const profile = await manager.client.getProfile(fid);
+          managerStatuses[agentId][accountId] = {
+            status: "healthy",
+            fid: profile.fid,
+            username: profile.username
+          };
+        } catch (error) {
+          managerStatuses[agentId][accountId] = {
+            status: "unhealthy",
+            error: error instanceof Error ? error.message : "Unknown error"
+          };
+          overallHealthy = false;
+        }
+      }
+    }
+    return {
+      healthy: overallHealthy,
+      details: {
+        activeManagers: Array.from(this.agents.values()).reduce((total, accounts) => total + accounts.managers.size, 0),
+        managerStatuses
+      }
+    };
+  }
+  getActiveManagers() {
+    return new Map(Array.from(this.agents.entries()).flatMap(([agentId, accounts]) => Array.from(accounts.managers.entries()).map(([accountId, manager]) => [`${agentId}:${accountId}`, manager])));
+  }
+  firstAgentId() {
+    return this.agents.keys().next().value;
+  }
+}
+
+// workflow-credential-provider.ts
+import { Service as Service2 } from "@elizaos/core";
+var WORKFLOW_CREDENTIAL_PROVIDER_TYPE = "workflow_credential_provider";
+var SUPPORTED = ["httpHeaderAuth"];
+
+class FarcasterWorkflowCredentialProvider extends Service2 {
+  static serviceType = WORKFLOW_CREDENTIAL_PROVIDER_TYPE;
+  capabilityDescription = "Supplies Farcaster (Neynar API) credentials to the workflow plugin.";
+  static async start(runtime) {
+    return new FarcasterWorkflowCredentialProvider(runtime);
+  }
+  async stop() {}
+  async resolve(_userId, credType) {
+    if (credType !== "httpHeaderAuth")
+      return null;
+    let neynarApiKey;
+    try {
+      neynarApiKey = this.runtime.getSetting("FARCASTER_NEYNAR_API_KEY");
+    } catch {
+      return null;
+    }
+    if (!neynarApiKey?.trim())
+      return null;
+    return {
+      status: "credential_data",
+      data: { name: "api_key", value: neynarApiKey.trim() }
+    };
+  }
+  checkCredentialTypes(credTypes) {
+    return {
+      supported: credTypes.filter((t) => SUPPORTED.includes(t)),
+      unsupported: credTypes.filter((t) => !SUPPORTED.includes(t))
+    };
+  }
+}
+
+// index.ts
+var farcasterPlugin = {
+  name: "farcaster",
+  description: "Farcaster client plugin for sending and receiving casts",
+  services: [FarcasterService, FarcasterWorkflowCredentialProvider],
+  actions: [],
+  providers: farcasterProviders,
+  routes: farcasterWebhookRoutes,
+  autoEnable: {
+    connectorKeys: ["farcaster"]
+  },
+  async init(_config, runtime) {
+    try {
+      const manager = getConnectorAccountManager(runtime);
+      manager.registerProvider(createFarcasterConnectorAccountProvider(runtime));
+    } catch (err) {
+      logger.warn({
+        src: "plugin:farcaster",
+        err: err instanceof Error ? err.message : String(err)
+      }, "Failed to register Farcaster provider with ConnectorAccountManager");
+    }
+  },
+  async dispose(runtime) {
+    await FarcasterService.stop(runtime);
+  }
+};
+var plugin_farcaster_default = farcasterPlugin;
+export {
+  resolveDefaultFarcasterAccountId,
+  readFarcasterAccountId,
+  normalizeFarcasterAccountId,
+  listFarcasterAccountIds,
+  isEmbedUrl,
+  isEmbedCast,
+  farcasterPlugin,
+  plugin_farcaster_default as default,
+  createFarcasterConnectorAccountProvider,
+  FarcasterService,
+  FarcasterClient,
+  FARCASTER_PROVIDER_ID,
+  EmbedManager,
+  DEFAULT_FARCASTER_ACCOUNT_ID
+};
+
+//# debugId=E5B04D3BB7E8528A64756E2164756E21