@elizaos/plugin-farcaster 2.0.0-alpha.7 → 2.0.0-beta.1

package/dist/cjs/index.node.cjs

@@ -1,397 +1,123 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
+  var entry = (__moduleCache ??= new WeakMap).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
-    }));
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
   __moduleCache.set(from, entry);
   return entry;
 };
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 
 // index.node.ts
 var exports_index_node = {};
 __export(exports_index_node, {
+  resolveDefaultFarcasterAccountId: () => resolveDefaultFarcasterAccountId,
+  readFarcasterAccountId: () => readFarcasterAccountId,
+  normalizeFarcasterAccountId: () => normalizeFarcasterAccountId,
+  listFarcasterAccountIds: () => listFarcasterAccountIds,
   isEmbedUrl: () => isEmbedUrl,
   isEmbedCast: () => isEmbedCast,
   farcasterPlugin: () => farcasterPlugin,
-  default: () => typescript_default,
+  default: () => import__2.default,
+  createFarcasterConnectorAccountProvider: () => createFarcasterConnectorAccountProvider,
   FarcasterService: () => FarcasterService,
   FarcasterClient: () => FarcasterClient,
-  EmbedManager: () => EmbedManager
+  FARCASTER_PROVIDER_ID: () => FARCASTER_PROVIDER_ID,
+  EmbedManager: () => EmbedManager,
+  DEFAULT_FARCASTER_ACCOUNT_ID: () => DEFAULT_FARCASTER_ACCOUNT_ID
 });
 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: "SEND_CAST",
-      description: "Posts a cast (message) on Farcaster",
-      similes: ["POST_CAST", "FARCASTER_POST", "CAST", "SHARE_ON_FARCASTER", "ANNOUNCE"],
-      parameters: []
-    },
-    {
-      name: "REPLY_TO_CAST",
-      description: "Replies to a cast on Farcaster",
-      similes: ["REPLY_CAST", "RESPOND_CAST", "ANSWER_CAST", "COMMENT_CAST"],
-      parameters: []
-    }
-  ]
-};
-var allActionsSpec = {
-  version: "1.0.0",
-  actions: [
-    {
-      name: "SEND_CAST",
-      description: "Posts a cast (message) on Farcaster",
-      similes: ["POST_CAST", "FARCASTER_POST", "CAST", "SHARE_ON_FARCASTER", "ANNOUNCE"],
-      parameters: []
-    },
-    {
-      name: "REPLY_TO_CAST",
-      description: "Replies to a cast on Farcaster",
-      similes: ["REPLY_CAST", "RESPOND_CAST", "ANSWER_CAST", "COMMENT_CAST"],
-      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;
+// index.ts
+var import_core11 = require("@elizaos/core");
 
-// 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;
-}
+// utils/config.ts
+var import_core = require("@elizaos/core");
+var import_zod = require("zod");
 
 // types/index.ts
-var import_zod = require("zod");
+var zod = __toESM(require("zod"));
+var z2 = zod.z ?? 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 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";
 
-// actions/replyCast.ts
-var spec = requireActionSpec("REPLY_TO_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, state, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avKeywords = ["reply", "cast"];
-    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
-    const __avRegex = /\b(?:reply|cast)\b/i;
-    const __avRegexOk = __avRegex.test(__avText);
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "farcaster";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (runtime2, message2) => {
-      const text = message2.content.text?.toLowerCase() || "";
-      const keywords = ["reply", "respond", "answer", "comment"];
-      const hasKeyword = keywords.some((keyword) => text.includes(keyword));
-      const hasParentCast = !!(message2.content.metadata && message2.content.metadata.parentCastHash);
-      const service = runtime2.getService(FARCASTER_SERVICE_NAME);
-      const isServiceAvailable = !!service?.getMessageService(runtime2.agentId);
-      return hasKeyword && (hasParentCast || isServiceAvailable);
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
-    }
-  },
-  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, state, options) => {
-    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
-    const __avText = __avTextRaw.toLowerCase();
-    const __avKeywords = ["send", "cast"];
-    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
-    const __avRegex = /\b(?:send|cast)\b/i;
-    const __avRegexOk = __avRegex.test(__avText);
-    const __avSource = String(message?.content?.source ?? message?.source ?? "");
-    const __avExpectedSource = "farcaster";
-    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
-    const __avOptions = options && typeof options === "object" ? options : {};
-    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
-    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
-      return false;
-    }
-    const __avLegacyValidate = async (runtime2, message2) => {
-      const text = message2.content.text?.toLowerCase() || "";
-      const keywords = ["post", "cast", "share", "announce", "farcaster"];
-      const hasKeyword = keywords.some((keyword) => text.includes(keyword));
-      const service = runtime2.getService(FARCASTER_SERVICE_NAME);
-      const isServiceAvailable = !!service?.getCastService(runtime2.agentId);
-      return hasKeyword && isServiceAvailable;
-    };
-    try {
-      return Boolean(await __avLegacyValidate(runtime, message, state, options));
-    } catch {
-      return false;
-    }
-  },
-  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");
+var DEFAULT_FARCASTER_ACCOUNT_ID = "default";
 function getProcessEnv() {
   if (typeof process === "undefined") {
     return {};
@@ -405,41 +131,138 @@ function safeParseInt(value, 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");
+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) {
-  const fid = runtime.getSetting("FARCASTER_FID");
-  const signerUuid = runtime.getSetting("FARCASTER_SIGNER_UUID");
-  const apiKey = runtime.getSetting("FARCASTER_NEYNAR_API_KEY");
+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) {
-  const fid = getFarcasterFid(runtime);
+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: runtime.getSetting("FARCASTER_DRY_RUN") || import_core3.parseBooleanFromText(env.FARCASTER_DRY_RUN || "false"),
+      FARCASTER_DRY_RUN: field(["FARCASTER_DRY_RUN", "dryRun"], "FARCASTER_DRY_RUN") || import_core.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"
+      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") || import_core.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") || import_core.parseBooleanFromText(env.ENABLE_ACTION_PROCESSING || "false"),
+      ACTION_INTERVAL: safeParseInt(field(["ACTION_INTERVAL", "actionInterval"], "ACTION_INTERVAL"), 5),
+      CAST_IMMEDIATELY: field(["CAST_IMMEDIATELY", "castImmediately"], "CAST_IMMEDIATELY") || import_core.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"}`);
@@ -459,9 +282,9 @@ function validateFarcasterConfig(runtime) {
     if (isDryRun) {
       runtime.logger.info("Farcaster client initialized in dry run mode - no actual casts should be posted");
     }
-    return config;
+    return { ...config, accountId: normalizedAccountId };
   } catch (error) {
-    if (error instanceof import_zod2.z.ZodError) {
+    if (error instanceof import_zod.z.ZodError) {
       const errorMessages = error.issues.map((err) => `${err.path.join(".")}: ${err.message}`).join(`
 `);
       throw new Error(`Farcaster configuration validation failed:
@@ -471,32 +294,143 @@ ${errorMessages}`);
   }
 }
 
+// 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 spec3 = requireProviderSpec("farcasterProfile");
+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: spec3.name,
+  name: spec.name,
   description: "Provides information about the agent's Farcaster profile",
+  descriptionCompressed: "provide information agent Farcaster profile",
   dynamic: true,
-  get: async (runtime, _message, _state) => {
+  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 managers = service?.getActiveManagers();
-      if (!managers || managers.size === 0) {
+      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 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);
+      const selectedAccountId = manager.config.accountId;
+      const fid = getFarcasterFid(runtime, selectedAccountId);
       if (!fid) {
         runtime.logger.warn("[FarcasterProfileProvider] Invalid or missing FARCASTER_FID");
         return {
@@ -506,18 +440,21 @@ var farcasterProfileProvider = {
       }
       try {
         const profile = await manager.client.getProfile(fid);
+        const username = truncateProfileField(profile.username) ?? "";
+        const name = truncateProfileField(profile.name);
         return {
-          text: `Your Farcaster profile: @${profile.username} (FID: ${profile.fid}). ${profile.name ? `Display name: ${profile.name}` : ""}`,
+          text: `Your Farcaster profile: @${username} (FID: ${profile.fid}). ${name ? `Display name: ${name}` : ""}`,
           data: {
             available: true,
             fid: profile.fid,
-            username: profile.username,
-            name: profile.name,
-            pfp: profile.pfp
+            username,
+            name,
+            pfp: profile.pfp,
+            accountId: selectedAccountId
           },
           values: {
             fid: profile.fid,
-            username: profile.username
+            username
           }
         };
       } catch (error) {
@@ -537,165 +474,38 @@ var farcasterProfileProvider = {
   }
 };
 
-// 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("farcasterThread");
-var farcasterThreadProvider = {
-  name: spec4.name,
-  description: "Provides thread context for Farcaster casts so the agent can reference the full conversation.",
-  dynamic: true,
-  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("farcasterTimeline");
-var farcasterTimelineProvider = {
-  name: spec5.name,
-  description: "Provides recent casts from the agent's Farcaster timeline",
-  dynamic: true,
-  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
-];
+var farcasterProviders = [farcasterProfileProvider];
 
 // routes/webhook.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isNeynarWebhookData(value) {
+  if (!isRecord(value) || typeof value.type !== "string")
+    return false;
+  if (value.data === undefined)
+    return true;
+  if (!isRecord(value.data))
+    return false;
+  if (typeof value.data.hash !== "string")
+    return false;
+  if (!isRecord(value.data.author) || typeof value.data.author.fid !== "number")
+    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) && typeof profile.fid === "number"))) {
+    return false;
+  }
+  if (value.data.parent_hash !== undefined && typeof value.data.parent_hash !== "string") {
+    return false;
+  }
+  if (value.data.parent_author !== undefined && !(isRecord(value.data.parent_author) && typeof value.data.parent_author.fid === "number")) {
+    return false;
+  }
+  return true;
+}
 var farcasterWebhookRoutes = [
   {
     type: "POST",
@@ -703,16 +513,25 @@ var farcasterWebhookRoutes = [
     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");
-        if (farcasterService) {
-          const agentManager = farcasterService.managers?.get?.(runtime.agentId ?? "");
-          if (agentManager?.interactions) {
-            if (agentManager.interactions.mode === "webhook") {
-              await agentManager.interactions.processWebhookData?.(webhookData);
-            }
+        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,
@@ -734,24 +553,24 @@ var farcasterWebhookRoutes = [
 ];
 
 // services/FarcasterService.ts
-var import_core11 = require("@elizaos/core");
+var import_core9 = 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_core3 = 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 import_core2 = require("@elizaos/core");
 var MAX_CAST_LENGTH = 1024;
 function castId({ hash, agentId }) {
   return `${hash}-${agentId}`;
 }
 function castUuid(props) {
-  return import_core4.stringToUuid(castId(props));
+  return import_core2.stringToUuid(castId(props));
 }
 function splitPostContent(content, maxLength = MAX_CAST_LENGTH) {
   const paragraphs = content.split(`
@@ -860,7 +679,8 @@ function createCastMemory({
   roomId,
   senderId,
   runtime,
-  cast
+  cast,
+  accountId
 }) {
   const inReplyTo = cast.inReplyTo ? castUuid({
     hash: cast.inReplyTo.hash,
@@ -876,17 +696,45 @@ function createCastMemory({
     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();
+  import_core3.elizaLogger.debug({ sdk: "neynar", op, ...context }, `[FarcasterClient] ${op} started`);
+  try {
+    const result = await fn();
+    import_core3.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);
+    import_core3.elizaLogger.warn({
+      sdk: "neynar",
+      op,
+      ...context,
+      durationMs: Date.now() - startedAt,
+      error: message
+    }, `[FarcasterClient] ${op} failed`);
+    throw error;
+  }
+}
 var castCache = new import_lru_cache.LRUCache({
   max: DEFAULT_CAST_CACHE_SIZE,
   ttl: DEFAULT_CAST_CACHE_TTL
@@ -921,21 +769,20 @@ class FarcasterClient {
   }
   async publishCast(cast, parentCastId) {
     try {
-      const result = await this.neynar.publishCast({
+      const result = await logNeynarCall("publishCast", { textLen: cast.length, parentHash: parentCastId?.hash ?? null }, async () => 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)}`);
+        import_core3.elizaLogger.error(`Neynar error: ${JSON.stringify(err.response.data)}`);
         throw err.response.data;
       } else {
-        import_core5.elizaLogger.error(`Error: ${JSON.stringify(err)}`);
         throw err;
       }
     }
@@ -945,19 +792,19 @@ class FarcasterClient {
     if (cachedCast) {
       return cachedCast;
     }
-    const response = await this.neynar.lookupCastByHashOrUrl({
+    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 this.neynar.fetchAllNotifications({
+    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;
@@ -971,35 +818,29 @@ class FarcasterClient {
     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;
+    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;
+    profile.bio = neynarUserProfile.profile.bio.text;
+    profile.pfp = neynarUserProfile.pfp_url;
+    profileCache.set(fid, profile);
+    return profile;
   }
   async getTimeline(request) {
     const timeline = [];
-    const response = await this.neynar.fetchCastsForUser({
+    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));
@@ -1016,42 +857,40 @@ class FarcasterClient {
   }
   async publishReaction(params) {
     try {
-      const result = await this.neynar.publishReaction({
+      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 (import_nodejs_sdk.isApiErrorResponse(err)) {
-        import_core5.elizaLogger.error(`Neynar error publishing reaction: ${JSON.stringify(err.response.data)}`);
+        import_core3.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({
+      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 (import_nodejs_sdk.isApiErrorResponse(err)) {
-        import_core5.elizaLogger.error(`Neynar error deleting reaction: ${JSON.stringify(err.response.data)}`);
+        import_core3.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");
+var import_core4 = require("@elizaos/core");
 
 // utils/callbacks.ts
 function standardCastHandlerCallback({
@@ -1065,6 +904,7 @@ function standardCastHandlerCallback({
 }) {
   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 [];
@@ -1082,7 +922,8 @@ function standardCastHandlerCallback({
           roomId,
           senderId: runtime.agentId,
           runtime,
-          cast: neynarCastToCast(cast)
+          cast: neynarCastToCast(cast),
+          accountId
         });
         if (i === 0) {
           memory.content.actions = content.actions;
@@ -1119,6 +960,9 @@ class FarcasterCastManager {
     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;
@@ -1161,43 +1005,56 @@ class FarcasterCastManager {
     }
   }
   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");
-    }
+    await import_core4.withStandaloneTrajectory(this.runtime, {
+      source: "plugin-farcaster:auto-cast",
+      metadata: {
+        platform: FARCASTER_SOURCE,
+        kind: "public_post_generation",
+        fid: this.fid,
+        accountId: this.getAccountId()
+      }
+    }, async () => {
+      import_core4.setTrajectoryPurpose("background");
+      this.runtime.logger.info("Generating new cast");
+      try {
+        const worldId = import_core4.createUniqueUuid(this.runtime, this.fid.toString());
+        const roomId = import_core4.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_core4.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
-var import_core8 = require("@elizaos/core");
+var import_core6 = require("@elizaos/core");
 
 // utils/asyncqueue.ts
 class AsyncQueue {
@@ -1261,12 +1118,12 @@ class AsyncQueue {
 }
 
 // managers/EmbedManager.ts
-var import_core7 = require("@elizaos/core");
+var import_core5 = require("@elizaos/core");
 function isEmbedUrl(embed) {
-  return "url" in embed && typeof embed.url === "string";
+  return "url" in embed;
 }
 function isEmbedCast(embed) {
-  return "cast" in embed && typeof embed.cast === "object";
+  return "cast" in embed;
 }
 function getMediaTypeFromUrl(url, contentType) {
   const lowerUrl = url.toLowerCase();
@@ -1360,10 +1217,10 @@ class EmbedManager {
     let description = "An image attachment";
     let title = "Image";
     try {
-      const result = await this.runtime.useModel(import_core7.ModelType.IMAGE_DESCRIPTION, {
+      const result = await import_core5.withStandaloneTrajectory(this.runtime, { source: "farcaster-embed" }, async () => this.runtime.useModel(import_core5.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;
@@ -1650,6 +1507,9 @@ class FarcasterInteractionManager {
     });
     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);
@@ -1744,9 +1604,9 @@ class FarcasterInteractionManager {
         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);
+      const entityId = import_core6.createUniqueUuid(this.runtime, cast.authorFid.toString());
+      const worldId = import_core6.createUniqueUuid(this.runtime, cast.authorFid.toString());
+      const roomId = import_core6.createUniqueUuid(this.runtime, conversationId);
       if (entityId !== this.runtime.agentId) {
         await this.runtime.ensureConnection({
           entityId,
@@ -1755,13 +1615,15 @@ class FarcasterInteractionManager {
           userName: cast.profile.username,
           name: cast.profile.name,
           source: FARCASTER_SOURCE,
-          type: import_core8.ChannelType.THREAD,
+          type: import_core6.ChannelType.THREAD,
           channelId: conversationId,
-          messageServerId: import_core8.stringToUuid(cast.authorFid.toString()),
+          messageServerId: import_core6.stringToUuid(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
@@ -1786,12 +1648,16 @@ class FarcasterInteractionManager {
             hash: cast.inReplyTo.hash
           }) : undefined,
           source: FARCASTER_SOURCE,
-          channelType: import_core8.ChannelType.THREAD,
+          accountId: this.getAccountId(),
+          channelType: import_core6.ChannelType.THREAD,
           attachments: cast.media && cast.media.length > 0 ? cast.media : undefined
         },
         entityId,
         roomId,
-        createdAt: cast.timestamp.getTime()
+        createdAt: cast.timestamp.getTime(),
+        metadata: {
+          accountId: this.getAccountId()
+        }
       };
       return memory;
     });
@@ -1820,7 +1686,8 @@ class FarcasterInteractionManager {
           runtime,
           memory: newMemory,
           cast: currentCast,
-          source: FARCASTER_SOURCE
+          source: FARCASTER_SOURCE,
+          accountId: self.getAccountId()
         });
       }
       thread.unshift(currentCast);
@@ -1874,6 +1741,7 @@ class FarcasterInteractionManager {
       memory,
       cast,
       source: FARCASTER_SOURCE,
+      accountId: this.getAccountId(),
       callback
     };
     this.runtime.emitEvent("FARCASTER_MENTION_RECEIVED" /* MENTION_RECEIVED */, mentionPayload);
@@ -1894,8 +1762,10 @@ class FarcasterAgentManager {
   client;
   casts;
   interactions;
+  config;
   constructor(runtime, config) {
     this.runtime = runtime;
+    this.config = config;
     const signerUuid = config.FARCASTER_SIGNER_UUID;
     const neynarConfig = new import_nodejs_sdk2.Configuration({
       apiKey: config.FARCASTER_NEYNAR_API_KEY
@@ -1920,18 +1790,40 @@ class FarcasterAgentManager {
 }
 
 // services/CastService.ts
-var import_core9 = require("@elizaos/core");
+var import_core7 = require("@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) {
+  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);
+      const fid = getFarcasterFid(this.runtime, this.getAccountId());
       if (!fid) {
         this.runtime.logger.error("FARCASTER_FID is not configured");
         return [];
@@ -1974,6 +1866,7 @@ class FarcasterCastService {
         inReplyTo: params.replyTo?.hash,
         media: [],
         metadata: {
+          accountId: this.getAccountId(),
           castHash: cast.hash,
           authorFid: cast.authorFid,
           source: FARCASTER_SOURCE,
@@ -1987,6 +1880,58 @@ class FarcasterCastService {
       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() : "";
+    if (!text) {
+      throw new Error("Farcaster post connector requires non-empty text content.");
+    }
+    const parentHash = readContentString(content, ["parentHash", "replyTo", "replyToHash"]);
+    const fid = getFarcasterFid(this.runtime, this.getAccountId());
+    const cast = await this.createCast({
+      agentId: runtime.agentId,
+      roomId: import_core7.createUniqueUuid(runtime, `farcaster:feed:${fid ?? runtime.agentId}`),
+      text,
+      ...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 })}`);
   }
@@ -2052,7 +1997,7 @@ class FarcasterCastService {
   }
   async getMentions(params) {
     try {
-      const fid = getFarcasterFid(this.runtime);
+      const fid = getFarcasterFid(this.runtime, this.getAccountId());
       if (!fid) {
         this.runtime.logger.error("FARCASTER_FID is not configured");
         return [];
@@ -2073,7 +2018,7 @@ class FarcasterCastService {
   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, {
+      const response = await this.runtime.useModel(import_core7.ModelType.TEXT_SMALL, {
         prompt,
         maxTokens: 100
       });
@@ -2086,7 +2031,7 @@ class FarcasterCastService {
   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, {
+      const response = await this.runtime.useModel(import_core7.ModelType.TEXT_SMALL, {
         prompt,
         maxTokens: 100
       });
@@ -2102,9 +2047,9 @@ class FarcasterCastService {
   }
   async storeCastInMemory(roomId, cast) {
     try {
-      const entityId = import_core9.createUniqueUuid(this.runtime, cast.userId);
+      const entityId = import_core7.createUniqueUuid(this.runtime, cast.userId);
       const memory = {
-        id: import_core9.createUniqueUuid(this.runtime, cast.id),
+        id: import_core7.createUniqueUuid(this.runtime, cast.id),
         agentId: this.runtime.agentId,
         entityId,
         content: {
@@ -2112,7 +2057,11 @@ class FarcasterCastService {
           castHash: String(cast.metadata?.castHash || ""),
           castId: cast.id,
           author: cast.username,
-          timestamp: cast.timestamp
+          timestamp: cast.timestamp,
+          accountId: this.getAccountId()
+        },
+        metadata: {
+          accountId: this.getAccountId()
         },
         roomId,
         createdAt: Date.now()
@@ -2122,11 +2071,58 @@ class FarcasterCastService {
       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 : import_core7.createUniqueUuid(runtime, `farcaster:user:${authorId}`);
+    const roomId = cast.roomId || import_core7.createUniqueUuid(runtime, `farcaster:feed:${authorId}`);
+    const castHash = typeof cast.metadata?.castHash === "string" ? cast.metadata.castHash : cast.id;
+    return {
+      id: import_core7.createUniqueUuid(runtime, `farcaster:cast:${castHash}`),
+      agentId: runtime.agentId,
+      entityId,
+      roomId,
+      createdAt: cast.timestamp || Date.now(),
+      content: {
+        text: cast.text,
+        source: FARCASTER_SOURCE,
+        channelType: import_core7.ChannelType.FEED,
+        ...cast.inReplyTo ? { inReplyTo: import_core7.createUniqueUuid(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: import_core7.ChannelType.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: import_core9.createUniqueUuid(this.runtime, cast.threadId || cast.hash),
+      roomId: import_core7.createUniqueUuid(this.runtime, cast.threadId || cast.hash),
       userId: cast.profile.fid.toString(),
       username: cast.profile.username,
       text: cast.text,
@@ -2136,6 +2132,7 @@ class FarcasterCastService {
         castHash: cast.hash,
         authorFid: cast.authorFid,
         source: FARCASTER_SOURCE,
+        accountId: this.getAccountId(),
         ...cast.threadId ? { threadId: cast.threadId } : {},
         ...cast.stats ? {
           recasts: cast.stats.recasts,
@@ -2148,19 +2145,24 @@ class FarcasterCastService {
 }
 
 // services/MessageService.ts
-var import_core10 = require("@elizaos/core");
+var import_core8 = require("@elizaos/core");
 class FarcasterMessageService {
   client;
   runtime;
-  constructor(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: import_core10.createUniqueUuid(this.runtime, cast.threadId || cast.hash),
+      roomId: import_core8.createUniqueUuid(this.runtime, cast.threadId || cast.hash),
       userId: cast.profile.fid.toString(),
       username: cast.profile.username,
       text: cast.text,
@@ -2169,6 +2171,7 @@ class FarcasterMessageService {
       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,
@@ -2179,7 +2182,7 @@ class FarcasterMessageService {
   async getMessages(options) {
     try {
       const { agentId, roomId, limit = 20 } = options;
-      const fid = getFarcasterFid(this.runtime);
+      const fid = getFarcasterFid(this.runtime, this.getAccountId());
       if (!fid) {
         this.runtime.logger.error("[Farcaster] FARCASTER_FID is not configured");
         return [];
@@ -2203,11 +2206,15 @@ class FarcasterMessageService {
   }
   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);
+        const fid = getFarcasterFid(this.runtime, this.getAccountId());
         if (!fid) {
           throw new Error("FARCASTER_FID is not configured");
         }
@@ -2227,15 +2234,16 @@ class FarcasterMessageService {
       const message = this.castToMessage(cast, agentId, options.metadata);
       message.roomId = roomId;
       message.type = type;
-      const castGeneratedPayload = {
+      const postGeneratedPayload = {
         runtime: this.runtime,
         source: FARCASTER_SOURCE,
         castHash: cast.hash,
         ...cast.threadId ? { threadId: cast.threadId } : {},
         messageId: message.id,
-        roomId
+        roomId,
+        accountId: this.getAccountId()
       };
-      await this.runtime.emitEvent("FARCASTER_CAST_GENERATED" /* CAST_GENERATED */, castGeneratedPayload);
+      await this.runtime.emitEvent("FARCASTER_POST_GENERATED" /* POST_GENERATED */, postGeneratedPayload);
       return message;
     } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
@@ -2285,11 +2293,9 @@ class FarcasterMessageService {
 }
 
 // services/FarcasterService.ts
-class FarcasterService extends import_core11.Service {
+class FarcasterService extends import_core9.Service {
   static instance;
-  managers = new Map;
-  messageServices = new Map;
-  castServices = new Map;
+  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";
@@ -2304,8 +2310,7 @@ class FarcasterService extends import_core11.Service {
   }
   static async start(runtime) {
     const service = FarcasterService.getInstance();
-    let manager = service.managers.get(runtime.agentId);
-    if (manager) {
+    if (service.agents.has(runtime.agentId)) {
       runtime.logger.warn({ agentId: runtime.agentId }, "Farcaster service already started");
       return service;
     }
@@ -2313,80 +2318,213 @@ class FarcasterService extends import_core11.Service {
       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");
+    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 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);
+    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: import_core9.ChannelType.FEED
+          }
+        }
+      });
+    }
+    runtime.logger.info({ src: "plugin:farcaster", agentId: runtime.agentId }, "Registered Farcaster post connector");
+  }
   async stop() {
-    for (const manager of Array.from(this.managers.values())) {
-      const agentId = manager.runtime.agentId;
-      manager.runtime.logger.debug("Stopping Farcaster service");
+    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 {
-        await FarcasterService.stop(manager.runtime);
+        if (runtime) {
+          await FarcasterService.stop(runtime);
+        } else {
+          this.agents.delete(agentId);
+        }
       } catch (error) {
-        manager.runtime.logger.error({ agentId, error }, "Error stopping Farcaster service");
+        runtime?.logger.error({ agentId, error }, "Error stopping Farcaster service");
       }
     }
   }
-  getMessageService(agentId) {
-    return this.messageServices.get(agentId);
+  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);
   }
-  getCastService(agentId) {
-    return this.castServices.get(agentId);
+  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, manager] of Array.from(this.managers.entries())) {
-      try {
-        const fid = getFarcasterFid(manager.runtime);
-        if (!fid) {
-          throw new Error("FARCASTER_FID not configured");
+    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;
         }
-        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,
+        activeManagers: Array.from(this.agents.values()).reduce((total, accounts) => total + accounts.managers.size, 0),
         managerStatuses
       }
     };
   }
   getActiveManagers() {
-    return new Map(this.managers);
+    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
+var import_core10 = require("@elizaos/core");
+var WORKFLOW_CREDENTIAL_PROVIDER_TYPE = "workflow_credential_provider";
+var SUPPORTED = ["httpHeaderAuth"];
+
+class FarcasterWorkflowCredentialProvider extends import_core10.Service {
+  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;
+    const neynarApiKey = this.runtime.getSetting("FARCASTER_NEYNAR_API_KEY");
+    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))
+    };
   }
 }
 
@@ -2394,11 +2532,24 @@ class FarcasterService extends import_core11.Service {
 var farcasterPlugin = {
   name: "farcaster",
   description: "Farcaster client plugin for sending and receiving casts",
-  services: [FarcasterService],
-  actions: farcasterActions,
+  services: [FarcasterService, FarcasterWorkflowCredentialProvider],
+  actions: [],
   providers: farcasterProviders,
-  routes: farcasterWebhookRoutes
+  routes: farcasterWebhookRoutes,
+  autoEnable: {
+    connectorKeys: ["farcaster"]
+  },
+  async init(_config, runtime) {
+    try {
+      const manager = import_core11.getConnectorAccountManager(runtime);
+      manager.registerProvider(createFarcasterConnectorAccountProvider(runtime));
+    } catch (err) {
+      import_core11.logger.warn({
+        src: "plugin:farcaster",
+        err: err instanceof Error ? err.message : String(err)
+      }, "Failed to register Farcaster provider with ConnectorAccountManager");
+    }
+  }
 };
-var typescript_default = farcasterPlugin;
 
-//# debugId=B8FD2BC4C288FA1B64756E2164756E21
+//# debugId=24E35985E5D4101664756E2164756E21