@beeperbot/sdk 0.2.1 → 0.2.3

package/dist/index.cjs

@@ -908,8 +908,16 @@ var ENDPOINTS = {
   PREVIEW: "/agent/preview",
   BULK_INTENT: "/agent/bulk-intent"
 };
-var AgentClient = class {
+var AgentClient = class _AgentClient {
   http;
+  static CHAIN_ID_MAP = {
+    base: 8453,
+    ethereum: 1,
+    mainnet: 1,
+    arbitrum: 42161,
+    polygon: 137,
+    optimism: 10
+  };
   constructor(config) {
     if (!config.apiKey) {
       throw BeeperError.validation("API key is required");
@@ -924,6 +932,62 @@ var AgentClient = class {
     });
     this.http = new HttpClient(httpConfig);
   }
+  /**
+   * Normalize filters for agent endpoints (accepts flexible shapes from other builders)
+   */
+  normalizeFilters(filters) {
+    const normalized = { ...filters };
+    const stripEmptyArray = (key) => {
+      const val = normalized[key];
+      if (Array.isArray(val) && val.length === 0) {
+        delete normalized[key];
+      }
+    };
+    const stripZero = (key) => {
+      const val = normalized[key];
+      if (typeof val === "number" && val === 0) {
+        delete normalized[key];
+      }
+    };
+    if (normalized.platform === "all") delete normalized.platform;
+    if (normalized.spamLabel === "all") delete normalized.spamLabel;
+    stripZero("minFollowers");
+    stripZero("maxFollowers");
+    stripZero("activeInLastDays");
+    stripZero("minBatteryPercentage");
+    stripZero("hasRechargedInLastDays");
+    stripZero("maxAttentionPriceUsd");
+    if (normalized.neynarScoreMin === 0) delete normalized.neynarScoreMin;
+    if (normalized.neynarScoreMax === 1) delete normalized.neynarScoreMax;
+    if (normalized.quotientScoreMin === 0) delete normalized.quotientScoreMin;
+    if (normalized.quotientScoreMax === 1) delete normalized.quotientScoreMax;
+    if (Array.isArray(normalized.countries)) {
+      normalized.countries = normalized.countries.map((c) => typeof c === "string" ? c : c?.code).filter((c) => typeof c === "string" && c.trim().length > 0).map((c) => c.trim().toUpperCase());
+    }
+    stripEmptyArray("countries");
+    if (Array.isArray(normalized.tokenHolders)) {
+      normalized.tokenHolders = normalized.tokenHolders.map((holder) => {
+        if (!holder) return null;
+        if ("tokenAddress" in holder && "chainId" in holder) return holder;
+        const contractAddress = holder.contractAddress;
+        const chain = holder.chain;
+        const minBalance = holder.minBalance;
+        if (!contractAddress || chain == null) return null;
+        const chainId = typeof chain === "number" ? chain : _AgentClient.CHAIN_ID_MAP[String(chain).toLowerCase()] ?? Number(chain);
+        if (!Number.isFinite(chainId)) return null;
+        return {
+          tokenAddress: contractAddress,
+          chainId,
+          ...minBalance ? { minBalance } : {}
+        };
+      }).filter((holder) => !!holder);
+    }
+    stripEmptyArray("tokenHolders");
+    stripEmptyArray("signalTokens");
+    stripEmptyArray("fids");
+    stripEmptyArray("userIds");
+    return normalized;
+  }
   /**
    * Look up a user by username, FID, or wallet address
    *
@@ -1054,7 +1118,7 @@ var AgentClient = class {
     const response = await this.http.post(
       ENDPOINTS.ESTIMATE,
       {
-        filters: input.filters,
+        filters: this.normalizeFilters(input.filters),
         budgetUsd: budgetStr,
         message: input.message
       }
@@ -1084,7 +1148,7 @@ var AgentClient = class {
     const response = await this.http.post(
       ENDPOINTS.PREVIEW,
       {
-        filters: input.filters,
+        filters: this.normalizeFilters(input.filters),
         limit
       }
     );
@@ -1116,7 +1180,7 @@ var AgentClient = class {
     const response = await this.http.post(
       ENDPOINTS.BULK_INTENT,
       {
-        filters: input.filters,
+        filters: this.normalizeFilters(input.filters),
         budgetUsd: budgetStr,
         message: input.message,
         chainId: input.chainId ?? 8453
@@ -1160,6 +1224,530 @@ var AgentClient = class {
   }
 };
 
+// src/core/agent/errors.ts
+var AgentCoreError = class _AgentCoreError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "AgentCoreError";
+    this.code = code;
+  }
+  static validation(message) {
+    return new _AgentCoreError("VALIDATION_ERROR", message);
+  }
+  static notFound(message) {
+    return new _AgentCoreError("NOT_FOUND", message);
+  }
+  static unsupportedChain(chainId) {
+    return new _AgentCoreError("UNSUPPORTED_CHAIN", `Unsupported chain: ${chainId}`);
+  }
+  static noRecipients(message) {
+    return new _AgentCoreError("NO_RECIPIENTS", message);
+  }
+};
+
+// src/core/agent/filters.ts
+var CHAIN_ID_MAP = {
+  base: 8453,
+  ethereum: 1,
+  mainnet: 1,
+  arbitrum: 42161,
+  polygon: 137,
+  optimism: 10
+};
+function hasSubstantiveFilters(filters) {
+  return !!(filters.platform || filters.minFollowers || filters.maxFollowers || filters.fids?.length || filters.userIds?.length || filters.activeInLastDays || filters.countries?.length || filters.neynarScoreMin || filters.tokenHolders?.length || filters.maxAttentionPriceUsd || filters.hasBaseWallet || filters.spamLabel);
+}
+function normalizeAgentFilters(filters) {
+  const normalized = { ...filters };
+  const defaultsApplied = [];
+  const stripEmptyArray = (key) => {
+    const value = normalized[key];
+    if (Array.isArray(value) && value.length === 0) {
+      delete normalized[key];
+    }
+  };
+  const stripZero = (key) => {
+    const value = normalized[key];
+    if (typeof value === "number" && value === 0) {
+      delete normalized[key];
+    }
+  };
+  if (normalized.platform === "all") delete normalized.platform;
+  if (normalized.spamLabel === "all") delete normalized.spamLabel;
+  stripZero("minFollowers");
+  stripZero("maxFollowers");
+  stripZero("activeInLastDays");
+  stripZero("minBatteryPercentage");
+  stripZero("hasRechargedInLastDays");
+  stripZero("maxAttentionPriceUsd");
+  stripEmptyArray("signalTokens");
+  if (Array.isArray(normalized.tokenHolders)) {
+    normalized.tokenHolders = normalized.tokenHolders.map((holder) => {
+      if (!holder) return null;
+      if ("tokenAddress" in holder && "chainId" in holder) return holder;
+      const loose = holder;
+      if (!loose.contractAddress || loose.chain == null) return null;
+      const chainId = typeof loose.chain === "number" ? loose.chain : CHAIN_ID_MAP[String(loose.chain).toLowerCase()] ?? Number(loose.chain);
+      if (!Number.isFinite(chainId)) return null;
+      return {
+        tokenAddress: loose.contractAddress,
+        chainId,
+        ...loose.minBalance ? { minBalance: loose.minBalance } : {}
+      };
+    }).filter((holder) => !!holder);
+  }
+  stripEmptyArray("tokenHolders");
+  if (Array.isArray(normalized.countries)) {
+    normalized.countries = normalized.countries.map((country) => {
+      if (typeof country === "string") return country;
+      return country?.code;
+    }).filter((country) => typeof country === "string" && country.length > 0).map((country) => country.toUpperCase());
+  }
+  stripEmptyArray("countries");
+  stripEmptyArray("fids");
+  stripEmptyArray("userIds");
+  if (normalized.neynarScoreMin === 0) delete normalized.neynarScoreMin;
+  if (normalized.neynarScoreMax === 1) delete normalized.neynarScoreMax;
+  if (normalized.quotientScoreMin === 0) delete normalized.quotientScoreMin;
+  if (normalized.quotientScoreMax === 1) delete normalized.quotientScoreMax;
+  if (!hasSubstantiveFilters(normalized)) {
+    normalized.activeInLastDays = 30;
+    normalized.spamLabel = "not_spam_only";
+    defaultsApplied.push("activeInLastDays=30", "spamLabel=not_spam_only");
+  }
+  return { filters: normalized, defaultsApplied };
+}
+function getOrderByOrDefault(filters) {
+  return filters.orderBy ?? "attention_price_asc";
+}
+function buildAgentQueryPlan(filters) {
+  const normalized = normalizeAgentFilters(filters);
+  return {
+    inputFilters: { ...filters },
+    filters: normalized.filters,
+    orderBy: getOrderByOrDefault(normalized.filters),
+    defaultsApplied: normalized.defaultsApplied
+  };
+}
+
+// src/core/agent/costing.ts
+var DEFAULT_MICRO_USD_PER_USD = 1e6;
+var DEFAULT_PLATFORM_FEE_RATE = 0.1;
+var GOAL_BASELINES = {
+  max_reach: { payout: 100, bonus: 0 },
+  lil_mission: { payout: 80, bonus: 20 },
+  hard_mission: { payout: 50, bonus: 50 }
+};
+var SPLIT_ADJUSTMENTS = {
+  balanced: 0,
+  more_reach: 10,
+  more_action: -10
+};
+function computeBudgetSplit(totalUsd, goalType = "max_reach", splitPreset = "balanced", platformFeeRate = DEFAULT_PLATFORM_FEE_RATE) {
+  const baseline = GOAL_BASELINES[goalType];
+  const adjustment = SPLIT_ADJUSTMENTS[splitPreset];
+  let payoutPercent = Math.max(0, Math.min(100, baseline.payout + adjustment));
+  let bonusPercent = Math.max(0, Math.min(100, baseline.bonus - adjustment));
+  const sum = payoutPercent + bonusPercent;
+  if (sum !== 100) {
+    payoutPercent = payoutPercent / sum * 100;
+    bonusPercent = bonusPercent / sum * 100;
+  }
+  const payoutUsd = roundToCents(totalUsd * payoutPercent / 100);
+  const bonusUsd = roundToCents(totalUsd * bonusPercent / 100);
+  const platformFeeUsd = roundToCents(totalUsd * platformFeeRate);
+  const userPaysUsd = roundToCents(totalUsd + platformFeeUsd);
+  return {
+    totalUsd,
+    payoutUsd,
+    bonusUsd,
+    platformFeeUsd,
+    userPaysUsd,
+    goalType,
+    splitPreset,
+    payoutPercent: Math.round(payoutPercent),
+    bonusPercent: Math.round(bonusPercent)
+  };
+}
+function roundToCents(value) {
+  return Math.round(value * 100) / 100;
+}
+function parseUsd(value) {
+  return parseFloat(value.replace(/^\$/, "").trim());
+}
+function usdToMicroUsd(usd, microUsdPerUsd = DEFAULT_MICRO_USD_PER_USD) {
+  return Math.round(usd * microUsdPerUsd);
+}
+
+// src/core/agent/engine.ts
+var DEFAULT_CHAIN_INFO = {
+  8453: { name: "Base", usdcAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" }
+};
+var AgentCore = class {
+  adapter;
+  defaultChainId;
+  platformFeeRate;
+  estimateMaxUsers;
+  bulkMaxUsers;
+  microUsdPerUsd;
+  chainInfo;
+  constructor(adapter, config = {}) {
+    this.adapter = adapter;
+    this.defaultChainId = config.defaultChainId ?? 8453;
+    this.platformFeeRate = config.platformFeeRate ?? DEFAULT_PLATFORM_FEE_RATE;
+    this.estimateMaxUsers = config.estimateMaxUsers ?? 1e4;
+    this.bulkMaxUsers = config.bulkMaxUsers ?? 1e4;
+    this.microUsdPerUsd = config.microUsdPerUsd ?? DEFAULT_MICRO_USD_PER_USD;
+    this.chainInfo = config.chainInfo ?? DEFAULT_CHAIN_INFO;
+  }
+  buildQueryPlan(filters) {
+    return buildAgentQueryPlan(filters);
+  }
+  normalizeFilters(filters) {
+    return normalizeAgentFilters(filters);
+  }
+  computeBudgetSplit(totalUsd, goalType = "max_reach", splitPreset = "balanced") {
+    return computeBudgetSplit(totalUsd, goalType, splitPreset, this.platformFeeRate);
+  }
+  async lookup(query) {
+    const user = await this.adapter.resolveUser(query);
+    if (!user) return null;
+    const fid = user.fid ?? await this.adapter.getFidForUser(user.id) ?? void 0;
+    const walletAddress = user.walletAddress ?? await this.adapter.getPrimaryWalletAddress(user.id) ?? void 0;
+    return {
+      id: user.id,
+      username: user.username,
+      platform: user.platform,
+      attentionPriceUsd: (Number(user.attentionPriceMicroUsd) / this.microUsdPerUsd).toFixed(2),
+      ...fid !== void 0 ? { fid } : {},
+      ...user.displayName ? { displayName: user.displayName } : {},
+      ...user.pfpUrl ? { pfpUrl: user.pfpUrl } : {},
+      ...walletAddress ? { walletAddress } : {},
+      ...user.followerCount !== void 0 ? { followerCount: user.followerCount } : {}
+    };
+  }
+  async getPrice(query) {
+    const user = await this.lookup(query);
+    if (!user) return null;
+    const priceUsdNum = parseFloat(user.attentionPriceUsd);
+    return {
+      userId: user.id,
+      username: user.username,
+      priceUsd: user.attentionPriceUsd,
+      priceUsdc: usdToMicroUsd(priceUsdNum, this.microUsdPerUsd).toString()
+    };
+  }
+  async prepareBeep(params) {
+    const user = await this.lookup(params.to);
+    if (!user) {
+      return { error: "user_not_found", message: `User not found: ${params.to}` };
+    }
+    if (!user.walletAddress) {
+      return { error: "no_wallet", message: `@${user.username} has no connected wallet` };
+    }
+    const baseAmount = parseUsd(params.amountUsd);
+    if (Number.isNaN(baseAmount) || baseAmount <= 0) {
+      return { error: "invalid_amount", message: "Amount must be a positive number" };
+    }
+    const attentionPrice = parseFloat(user.attentionPriceUsd);
+    if (baseAmount < attentionPrice) {
+      return {
+        error: "below_minimum",
+        message: `Amount $${baseAmount.toFixed(2)} is below @${user.username}'s minimum beep price of $${attentionPrice.toFixed(2)}.`,
+        minimumUsd: user.attentionPriceUsd,
+        requestedUsd: params.amountUsd
+      };
+    }
+    const chainId = params.chainId ?? this.defaultChainId;
+    const chain = this.chainInfo[chainId];
+    if (!chain) {
+      return { error: "unsupported_chain", message: `Chain ${chainId} is not supported` };
+    }
+    const goalType = params.goalType ?? (params.bonusConfig ? "lil_mission" : "max_reach");
+    const hasMissions = goalType !== "max_reach";
+    const splitPreset = params.splitPreset ?? "balanced";
+    const split = hasMissions ? this.computeBudgetSplit(baseAmount, goalType, splitPreset) : void 0;
+    const platformFeeUsd = Math.round(baseAmount * this.platformFeeRate * 100) / 100;
+    const totalAmountUsd = baseAmount + platformFeeUsd;
+    const result = {
+      type: "confirmation",
+      recipient: {
+        username: user.username,
+        walletAddress: user.walletAddress,
+        ...user.displayName ? { displayName: user.displayName } : {},
+        ...user.pfpUrl ? { pfpUrl: user.pfpUrl } : {},
+        ...user.fid !== void 0 ? { fid: user.fid } : {}
+      },
+      message: params.message,
+      baseAmountUsd: baseAmount.toFixed(2),
+      platformFeeUsd: platformFeeUsd.toFixed(2),
+      totalAmountUsd: totalAmountUsd.toFixed(2),
+      feePercentage: this.platformFeeRate * 100,
+      chainId,
+      chainName: chain.name,
+      attentionPriceUsd: user.attentionPriceUsd
+    };
+    if (hasMissions && split) {
+      result.hasMissions = true;
+      result.budgetSplit = split;
+      if (params.bonusConfig) {
+        result.bonusConfig = params.bonusConfig;
+      }
+    }
+    return result;
+  }
+  async createIntent(params) {
+    const user = await this.lookup(params.to);
+    if (!user || !user.walletAddress) return null;
+    const baseAmountUsd = parseUsd(params.amountUsd);
+    if (Number.isNaN(baseAmountUsd) || baseAmountUsd <= 0) {
+      throw AgentCoreError.validation("Invalid amount");
+    }
+    const chainId = params.chainId ?? this.defaultChainId;
+    const chain = this.chainInfo[chainId];
+    if (!chain) throw AgentCoreError.unsupportedChain(chainId);
+    const platformFeeUsd = Math.round(baseAmountUsd * this.platformFeeRate * 100) / 100;
+    const totalAmountUsd = baseAmountUsd + platformFeeUsd;
+    const amountUsdc = usdToMicroUsd(totalAmountUsd, this.microUsdPerUsd).toString();
+    const intentId = `intent_${crypto.randomUUID()}`;
+    const shortAddress = `${user.walletAddress.slice(0, 6)}...${user.walletAddress.slice(-4)}`;
+    const message = params.message ?? "";
+    return {
+      intentId,
+      recipient: user.walletAddress,
+      amount: amountUsdc,
+      amountFormatted: `${totalAmountUsd.toFixed(2)} USDC`,
+      tokenAddress: chain.usdcAddress,
+      tokenSymbol: "USDC",
+      chainId,
+      chainName: chain.name,
+      message,
+      recipientInfo: {
+        username: user.username,
+        ...user.displayName ? { displayName: user.displayName } : {},
+        ...user.fid !== void 0 ? { fid: user.fid } : {}
+      },
+      instruction: `Send ${totalAmountUsd.toFixed(2)} USDC to ${shortAddress} on ${chain.name} (${baseAmountUsd.toFixed(2)} to @${user.username} + ${platformFeeUsd.toFixed(2)} platform fee)`,
+      expiresAt: new Date(Date.now() + 60 * 60 * 1e3).toISOString(),
+      baseAmountUsd: baseAmountUsd.toFixed(2),
+      platformFeeUsd: platformFeeUsd.toFixed(2),
+      totalAmountUsd: totalAmountUsd.toFixed(2),
+      feePercentage: this.platformFeeRate * 100
+    };
+  }
+  async estimate(params) {
+    const budgetUsd = parseUsd(params.budgetUsd);
+    if (Number.isNaN(budgetUsd) || budgetUsd <= 0) {
+      throw AgentCoreError.validation("Budget must be a positive number");
+    }
+    const plan = this.buildQueryPlan(params.filters);
+    const candidates = await this.adapter.findUsers({
+      filters: plan.filters,
+      orderBy: plan.orderBy,
+      limit: this.estimateMaxUsers
+    });
+    const budgetMicro = usdToMicroUsd(budgetUsd, this.microUsdPerUsd);
+    let totalCost = 0;
+    let recipientCount = 0;
+    let minPrice = Number.POSITIVE_INFINITY;
+    let maxPrice = 0;
+    for (const candidate of candidates) {
+      const priceMicro = Number(candidate.attentionPriceMicroUsd);
+      if (totalCost + priceMicro > budgetMicro) break;
+      totalCost += priceMicro;
+      recipientCount += 1;
+      if (priceMicro < minPrice) minPrice = priceMicro;
+      if (priceMicro > maxPrice) maxPrice = priceMicro;
+    }
+    const avgPrice = recipientCount > 0 ? totalCost / recipientCount : 0;
+    return {
+      recipientCount,
+      totalCostUsd: (totalCost / this.microUsdPerUsd).toFixed(2),
+      avgPriceUsd: (avgPrice / this.microUsdPerUsd).toFixed(2),
+      minPriceUsd: recipientCount > 0 ? (minPrice / this.microUsdPerUsd).toFixed(2) : "0.00",
+      maxPriceUsd: recipientCount > 0 ? (maxPrice / this.microUsdPerUsd).toFixed(2) : "0.00",
+      remainingBudgetUsd: ((budgetMicro - totalCost) / this.microUsdPerUsd).toFixed(2),
+      budgetSufficient: recipientCount > 0,
+      diagnostics: {
+        candidateCount: candidates.length,
+        budgetMicro,
+        appliedDefaults: plan.defaultsApplied
+      }
+    };
+  }
+  async preview(params) {
+    const limit = Math.min(Math.max(params.limit, 1), 20);
+    const plan = this.buildQueryPlan(params.filters);
+    const [users, totalCount] = await Promise.all([
+      this.adapter.findUsers({
+        filters: plan.filters,
+        orderBy: plan.orderBy,
+        limit,
+        includeProfile: true,
+        includeReputation: true
+      }),
+      this.adapter.countUsers(plan.filters)
+    ]);
+    const userIds = users.map((user) => user.id);
+    const fidMap = await this.adapter.getBulkFidsForUsers(userIds);
+    return {
+      users: users.map((user) => {
+        const previewUser = {
+          username: user.username,
+          priceUsd: (Number(user.attentionPriceMicroUsd) / this.microUsdPerUsd).toFixed(2),
+          ...user.displayName ? { displayName: user.displayName } : {},
+          ...user.followerCount !== void 0 ? { followerCount: user.followerCount } : {},
+          ...user.neynarScore !== void 0 ? { neynarScore: user.neynarScore } : {},
+          ...user.pfpUrl ? { pfpUrl: user.pfpUrl } : {}
+        };
+        const fid = fidMap.get(user.id);
+        if (fid !== void 0) {
+          return { ...previewUser, fid };
+        }
+        return previewUser;
+      }),
+      totalCount,
+      hasMore: totalCount > limit
+    };
+  }
+  async createBulkIntent(params) {
+    const budgetUsd = parseUsd(params.budgetUsd);
+    if (Number.isNaN(budgetUsd) || budgetUsd <= 0) {
+      throw AgentCoreError.validation("Budget must be a positive number");
+    }
+    const chainId = params.chainId ?? this.defaultChainId;
+    const chain = this.chainInfo[chainId];
+    if (!chain) throw AgentCoreError.unsupportedChain(chainId);
+    const plan = this.buildQueryPlan(params.filters);
+    const users = await this.adapter.findUsers({
+      filters: plan.filters,
+      orderBy: "attention_price_asc",
+      limit: this.bulkMaxUsers
+    });
+    const budgetMicro = usdToMicroUsd(budgetUsd, this.microUsdPerUsd);
+    let totalAmountMicro = 0;
+    const selectedUsers = [];
+    for (const user of users) {
+      const priceMicro = Number(user.attentionPriceMicroUsd);
+      if (totalAmountMicro + priceMicro > budgetMicro) break;
+      totalAmountMicro += priceMicro;
+      selectedUsers.push({
+        id: user.id,
+        username: user.username,
+        amountMicro: priceMicro
+      });
+    }
+    if (selectedUsers.length === 0) {
+      throw AgentCoreError.noRecipients("No eligible recipients within budget");
+    }
+    const walletMap = await this.adapter.getBulkPrimaryWalletAddresses(selectedUsers.map((u) => u.id));
+    const payments = selectedUsers.filter((user) => walletMap.has(user.id)).map((user) => ({
+      recipient: walletMap.get(user.id),
+      amount: user.amountMicro.toString(),
+      username: user.username
+    }));
+    if (payments.length === 0) {
+      throw AgentCoreError.noRecipients("No recipients with valid wallets found");
+    }
+    const totalAmount = payments.reduce((sum, payment) => sum + BigInt(payment.amount), 0n);
+    const totalFormatted = (Number(totalAmount) / this.microUsdPerUsd).toFixed(2);
+    return {
+      bulkIntentId: `bulk_${crypto.randomUUID()}`,
+      recipientCount: payments.length,
+      totalAmount: totalAmount.toString(),
+      totalAmountFormatted: `${totalFormatted} USDC`,
+      payments,
+      summary: `Send to ${payments.length} recipients for total ${totalFormatted} USDC on ${chain.name}`,
+      chainId,
+      chainName: chain.name,
+      tokenAddress: chain.usdcAddress,
+      tokenSymbol: "USDC",
+      expiresAt: new Date(Date.now() + 60 * 60 * 1e3).toISOString()
+    };
+  }
+  async prepareCampaign(params) {
+    const totalBudget = parseUsd(params.budgetUsd);
+    if (Number.isNaN(totalBudget) || totalBudget <= 0) {
+      throw AgentCoreError.validation("Budget must be a positive number");
+    }
+    const chainId = params.chainId ?? this.defaultChainId;
+    const chain = this.chainInfo[chainId];
+    if (!chain) throw AgentCoreError.unsupportedChain(chainId);
+    const goalType = params.goalType ?? (params.bonusConfig ? "lil_mission" : "max_reach");
+    const splitPreset = params.splitPreset ?? "balanced";
+    const split = this.computeBudgetSplit(totalBudget, goalType, splitPreset);
+    const payoutEstimate = await this.estimate({
+      filters: params.filters,
+      budgetUsd: split.payoutUsd.toFixed(2),
+      ...params.message ? { message: params.message } : {}
+    });
+    let missionSummary;
+    if (params.bonusConfig) {
+      const ctaLabels = params.bonusConfig.ctas.map((cta) => {
+        switch (cta.type) {
+          case "follow_profile":
+            return `Follow @${cta.profileUsername || cta.profileFid}`;
+          case "like_cast":
+            return "Like a cast";
+          case "recast":
+            return "Recast";
+          case "share_cast":
+            return "Quote cast";
+          case "visit_link":
+            return `Visit ${cta.label || cta.url || "link"}`;
+          case "quiz":
+            return `Quiz (${cta.questions?.length || 0} questions)`;
+          case "external_verify":
+            return cta.description || "Custom quest";
+          case "x_follow":
+            return `Follow @${cta.handle} on X`;
+          case "x_like":
+            return "Like tweet on X";
+          case "x_recast":
+            return "Repost on X";
+          default:
+            return cta.type;
+        }
+      });
+      const distributionLabel = params.bonusConfig.type === "lottery" ? "BEEPERY (lottery)" : "FCFS (first come)";
+      missionSummary = `${distributionLabel} \u2022 $${split.bonusUsd.toFixed(2)} pool \u2022 ${ctaLabels.join(", ")}`;
+    }
+    return {
+      type: "campaign_confirmation",
+      recipientCount: payoutEstimate.recipientCount,
+      budgetSplit: split,
+      payoutEstimate: {
+        recipientCount: payoutEstimate.recipientCount,
+        totalPayoutCostUsd: payoutEstimate.totalCostUsd,
+        avgPriceUsd: payoutEstimate.avgPriceUsd
+      },
+      platformFeeUsd: split.platformFeeUsd.toFixed(2),
+      userPaysUsd: split.userPaysUsd.toFixed(2),
+      chainId,
+      chainName: chain.name,
+      ...params.bonusConfig ? { bonusConfig: params.bonusConfig } : {},
+      ...missionSummary ? { missionSummary } : {},
+      ...params.message ? { message: params.message } : {}
+    };
+  }
+  async getBeepHistory(params) {
+    return this.adapter.getBeepHistory(params);
+  }
+};
+function createAgentCore(adapter, config) {
+  return new AgentCore(adapter, config);
+}
+function normalizeFilters(filters) {
+  return normalizeAgentFilters(filters);
+}
+function buildQueryPlan(filters) {
+  return buildAgentQueryPlan(filters);
+}
+function getDefaultOrderBy(filters) {
+  return buildAgentQueryPlan(filters).orderBy;
+}
+
 // src/client/auth.ts
 var API_KEY_PREFIXES = {
   LIVE: "bpk_live_",
@@ -1198,6 +1786,7 @@ function maskApiKey(apiKey) {
 }
 
 // src/client/BeeperClient.ts
+var ALLOWED_REWARD_TYPES = ["guaranteed", "lottery", "fcfs"];
 var QuoteSchema = zod.z.object({
   id: zod.z.string(),
   status: zod.z.enum([
@@ -1404,6 +1993,16 @@ var BeeperClient = class {
     if (input.message.length > 1e3) {
       throw BeeperError.validation("Message must be 1000 characters or less");
     }
+    if (input.rewardType !== void 0) {
+      if (input.rewardType.trim().length === 0) {
+        throw BeeperError.validation("rewardType must be a non-empty string");
+      }
+      if (!ALLOWED_REWARD_TYPES.includes(input.rewardType)) {
+        throw BeeperError.validation(
+          `rewardType must be one of: ${ALLOWED_REWARD_TYPES.join(", ")}`
+        );
+      }
+    }
     if (!input.recipientFids?.length && !input.filter) {
       throw BeeperError.validation("Must provide either recipientFids or filter");
     }
@@ -1422,6 +2021,7 @@ var BeeperClient = class {
       filter: input.filter,
       budgetUSD: input.budgetUSD,
       rewardType: input.rewardType ?? "guaranteed",
+      mode: "attention_marketplace",
       memo: input.memo,
       metadata: input.metadata,
       ttlSeconds: opts?.ttlSeconds ?? 300
@@ -2785,11 +3385,10 @@ var FilterBuilder = class _FilterBuilder {
         throw new Error("minBalance must be a numeric string (wei)");
       }
     }
-    const chainNames = { 1: "ethereum", 8453: "base", 42161: "arbitrum", 10: "optimism", 137: "polygon" };
     return new FilterExpression({
       cachedTokenHolders: opts.map((o) => ({
         contractAddress: o.tokenAddress,
-        chain: chainNames[o.chainId] ?? String(o.chainId),
+        chain: o.chainId === 8453 ? "base" : "ethereum",
         tokenStandard: o.tokenStandard ?? "ERC20",
         ...o.minBalance !== void 0 ? { minBalance: o.minBalance } : {},
         ...o.tokenId !== void 0 ? { tokenId: o.tokenId } : {}
@@ -3242,6 +3841,8 @@ exports.API_BASE_URLS = API_BASE_URLS;
 exports.API_KEY_PREFIXES = API_KEY_PREFIXES;
 exports.ActiveInLastDaysFilterSchema = ActiveInLastDaysFilterSchema;
 exports.AgentClient = AgentClient;
+exports.AgentCore = AgentCore;
+exports.AgentCoreError = AgentCoreError;
 exports.ApiQuoteResponseSchema = ApiQuoteResponseSchema;
 exports.ApiReceiptResponseSchema = ApiReceiptResponseSchema;
 exports.BeeperClient = BeeperClient;
@@ -3335,6 +3936,10 @@ exports.TokenHolderFilterSchema = TokenHolderFilterSchema;
 exports.TokenTypeSchema = TokenTypeSchema;
 exports.TransferStatusSchema = TransferStatusSchema;
 exports.VerifiedOnlyFilterSchema = VerifiedOnlyFilterSchema;
+exports.buildAgentCoreQueryPlan = buildQueryPlan;
+exports.buildAgentQueryPlan = buildAgentQueryPlan;
+exports.computeAgentBudgetSplit = computeBudgetSplit;
+exports.createAgentCore = createAgentCore;
 exports.createHttpConfig = createHttpConfig;
 exports.default = BeeperClient_default;
 exports.describeFilters = describeFilters;
@@ -3342,12 +3947,16 @@ exports.generateDepositIdempotencyKey = generateDepositIdempotencyKey;
 exports.generateExecuteIdempotencyKey = generateExecuteIdempotencyKey;
 exports.generateFilterDocumentation = generateFilterDocumentation;
 exports.generateIdempotencyKey = generateIdempotencyKey;
+exports.getAgentCoreDefaultOrderBy = getDefaultOrderBy;
 exports.getAllFilterNames = getAllFilterNames;
 exports.getApiKeyEnvironment = getApiKeyEnvironment;
 exports.getFilterSchema = getFilterSchema;
+exports.getOrderByOrDefault = getOrderByOrDefault;
 exports.isRetryableCode = isRetryableCode;
 exports.isValidApiKeyFormat = isValidApiKeyFormat;
 exports.maskApiKey = maskApiKey;
+exports.normalizeAgentCoreFilters = normalizeFilters;
+exports.normalizeAgentFilters = normalizeAgentFilters;
 exports.parseDraft = parseDraft;
 exports.parseDraftInput = parseDraftInput;
 exports.parseExecuteResult = parseExecuteResult;