@emblemvault/hustle-react 1.0.0

package/dist/plugins/index.js

@@ -0,0 +1,1225 @@
+// src/plugins/predictionMarket.ts
+var DOME_API_BASE = "https://api.domeapi.io/v1";
+var predictionMarketPlugin = {
+  name: "prediction-market-alpha",
+  version: "1.1.0",
+  description: "Search and analyze prediction markets on Polymarket and Kalshi",
+  tools: [
+    {
+      name: "get_supported_platforms",
+      description: "Get a list of supported prediction market platforms. Call this first to know which platforms are available for querying.",
+      parameters: {
+        type: "object",
+        properties: {}
+      }
+    },
+    {
+      name: "search_prediction_markets",
+      description: "Search for prediction markets. Find markets about politics, crypto, sports, and more. Returns market titles, current odds, volume, and status. You MUST provide tags to filter results.",
+      parameters: {
+        type: "object",
+        properties: {
+          platform: {
+            type: "string",
+            enum: ["polymarket", "kalshi"],
+            description: "The prediction market platform to search (default: polymarket)"
+          },
+          tags: {
+            type: "array",
+            items: { type: "string" },
+            description: 'REQUIRED: Single word categories or tags to identify a market segment (e.g., "politics", "crypto", "sports", "finance", "entertainment", "ai")'
+          },
+          status: {
+            type: "string",
+            enum: ["open", "closed"],
+            description: "Filter by market status"
+          },
+          limit: {
+            type: "number",
+            description: "Number of results (1-100)",
+            default: 10
+          }
+        },
+        required: ["tags"]
+      }
+    },
+    {
+      name: "get_market_details",
+      description: "Get detailed information about a specific prediction market including current prices, trading history, and resolution source.",
+      parameters: {
+        type: "object",
+        properties: {
+          platform: {
+            type: "string",
+            enum: ["polymarket", "kalshi"],
+            description: "The prediction market platform (default: polymarket)"
+          },
+          market_slug: {
+            type: "string",
+            description: "The market slug/identifier (ticker for Kalshi)"
+          }
+        },
+        required: ["market_slug"]
+      }
+    },
+    {
+      name: "get_market_prices",
+      description: "Get current prices/odds for a prediction market. Shows probability for each outcome.",
+      parameters: {
+        type: "object",
+        properties: {
+          platform: {
+            type: "string",
+            enum: ["polymarket", "kalshi"],
+            description: "The prediction market platform (default: polymarket)"
+          },
+          market_slug: {
+            type: "string",
+            description: "The market slug/identifier (ticker for Kalshi)"
+          }
+        },
+        required: ["market_slug"]
+      }
+    },
+    {
+      name: "get_market_trades",
+      description: "Get recent orders/trading activity for a prediction market.",
+      parameters: {
+        type: "object",
+        properties: {
+          platform: {
+            type: "string",
+            enum: ["polymarket", "kalshi"],
+            description: "The prediction market platform (default: polymarket)"
+          },
+          market_slug: {
+            type: "string",
+            description: "The market slug/identifier (ticker for Kalshi)"
+          },
+          limit: {
+            type: "number",
+            description: "Number of orders to return (max 100)",
+            default: 20
+          }
+        },
+        required: ["market_slug"]
+      }
+    }
+  ],
+  executors: {
+    get_supported_platforms: async () => {
+      return {
+        platforms: [
+          {
+            id: "polymarket",
+            name: "Polymarket",
+            description: "Decentralized prediction market on Polygon",
+            features: ["tags", "volume_filtering"]
+          },
+          {
+            id: "kalshi",
+            name: "Kalshi",
+            description: "CFTC-regulated prediction market exchange",
+            features: ["regulated", "event_based"]
+          }
+        ]
+      };
+    },
+    search_prediction_markets: async (args2) => {
+      const platform = args2.platform || "polymarket";
+      const params = new URLSearchParams();
+      if (args2.limit) params.append("limit", String(args2.limit));
+      if (platform === "polymarket") {
+        if (args2.tags) params.append("tags", args2.tags.join(","));
+        if (args2.status) params.append("status", args2.status);
+        const response = await fetch(`${DOME_API_BASE}/polymarket/markets?${params}`);
+        if (!response.ok) {
+          throw new Error(`Dome API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        return {
+          platform: "polymarket",
+          markets: data.markets?.map((m) => ({
+            slug: m.market_slug,
+            title: m.title,
+            status: m.status,
+            volume: m.volume_total,
+            tags: m.tags,
+            outcomes: [
+              { label: m.side_a?.label, id: m.side_a?.id },
+              { label: m.side_b?.label, id: m.side_b?.id }
+            ],
+            winner: m.winning_side
+          })) || [],
+          total: data.pagination?.total || 0,
+          hasMore: data.pagination?.has_more || false
+        };
+      } else if (platform === "kalshi") {
+        if (args2.status) params.append("status", args2.status);
+        const response = await fetch(`${DOME_API_BASE}/kalshi/markets?${params}`);
+        if (!response.ok) {
+          throw new Error(`Dome API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        return {
+          platform: "kalshi",
+          markets: data.markets?.map((m) => ({
+            ticker: m.ticker,
+            title: m.title,
+            status: m.status,
+            category: m.category,
+            subtitle: m.subtitle,
+            yesAsk: m.yes_ask,
+            yesBid: m.yes_bid,
+            volume: m.volume
+          })) || [],
+          total: data.pagination?.total || 0,
+          hasMore: data.pagination?.has_more || false
+        };
+      }
+      throw new Error(`Unsupported platform: ${platform}`);
+    },
+    get_market_details: async (args2) => {
+      const platform = args2.platform || "polymarket";
+      if (platform === "polymarket") {
+        const response = await fetch(
+          `${DOME_API_BASE}/polymarket/markets?market_slug=${args2.market_slug}`
+        );
+        if (!response.ok) {
+          throw new Error(`Dome API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        const market = data.markets?.[0];
+        if (!market) {
+          throw new Error(`Market not found: ${args2.market_slug}`);
+        }
+        return {
+          platform: "polymarket",
+          slug: market.market_slug,
+          title: market.title,
+          status: market.status,
+          startTime: market.start_time ? new Date(market.start_time * 1e3).toISOString() : null,
+          endTime: market.end_time ? new Date(market.end_time * 1e3).toISOString() : null,
+          volume: {
+            total: market.volume_total,
+            week: market.volume_1_week,
+            month: market.volume_1_month
+          },
+          resolutionSource: market.resolution_source,
+          outcomes: [
+            { label: market.side_a?.label, id: market.side_a?.id },
+            { label: market.side_b?.label, id: market.side_b?.id }
+          ],
+          winner: market.winning_side,
+          tags: market.tags
+        };
+      } else if (platform === "kalshi") {
+        const response = await fetch(
+          `${DOME_API_BASE}/kalshi/markets?ticker=${args2.market_slug}`
+        );
+        if (!response.ok) {
+          throw new Error(`Dome API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        const market = data.markets?.[0];
+        if (!market) {
+          throw new Error(`Market not found: ${args2.market_slug}`);
+        }
+        return {
+          platform: "kalshi",
+          ticker: market.ticker,
+          title: market.title,
+          subtitle: market.subtitle,
+          status: market.status,
+          category: market.category,
+          yesAsk: market.yes_ask,
+          yesBid: market.yes_bid,
+          volume: market.volume,
+          openInterest: market.open_interest
+        };
+      }
+      throw new Error(`Unsupported platform: ${platform}`);
+    },
+    get_market_prices: async (args2) => {
+      const platform = args2.platform || "polymarket";
+      if (platform === "polymarket") {
+        const response = await fetch(
+          `${DOME_API_BASE}/polymarket/market-price?market_slug=${args2.market_slug}`
+        );
+        if (!response.ok) {
+          throw new Error(`Dome API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        return { platform: "polymarket", ...data };
+      } else if (platform === "kalshi") {
+        const response = await fetch(
+          `${DOME_API_BASE}/kalshi/markets?ticker=${args2.market_slug}`
+        );
+        if (!response.ok) {
+          throw new Error(`Dome API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        const market = data.markets?.[0];
+        if (!market) {
+          throw new Error(`Market not found: ${args2.market_slug}`);
+        }
+        return {
+          platform: "kalshi",
+          ticker: market.ticker,
+          yesAsk: market.yes_ask,
+          yesBid: market.yes_bid,
+          lastPrice: market.last_price
+        };
+      }
+      throw new Error(`Unsupported platform: ${platform}`);
+    },
+    get_market_trades: async (args2) => {
+      const platform = args2.platform || "polymarket";
+      const limit = String(args2.limit || 20);
+      if (platform === "polymarket") {
+        const params = new URLSearchParams({
+          market_slug: args2.market_slug,
+          limit
+        });
+        const response = await fetch(
+          `${DOME_API_BASE}/polymarket/orders?${params}`
+        );
+        if (!response.ok) {
+          throw new Error(`Dome API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        return { platform: "polymarket", ...data };
+      } else if (platform === "kalshi") {
+        const params = new URLSearchParams({
+          ticker: args2.market_slug,
+          limit
+        });
+        const response = await fetch(
+          `${DOME_API_BASE}/kalshi/trades?${params}`
+        );
+        if (!response.ok) {
+          throw new Error(`Dome API error: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        return { platform: "kalshi", ...data };
+      }
+      throw new Error(`Unsupported platform: ${platform}`);
+    }
+  },
+  hooks: {
+    onRegister: () => {
+      console.log("[Plugin] Prediction Market Alpha v1.1.0 registered (Polymarket + Kalshi)");
+    }
+  }
+};
+
+// src/plugins/migrateFun.ts
+var QA = [
+  { id: "migration-steps-bonk", question: "What are all the steps for migrations to Bonk?", answer: `Here's how MigrateFun migrates your token to BonkFun:
+1) The creator/team sets up a migration portal through migratefun - Create new CA for BonkFun (Ticker, name, image, supply) and set timeline period (1-30 days, 14 days average)
+2) After portal setup, holders commit their tokens to migration - tokens are locked in migration vault until time period ends
+3) Once migration ends, ALL tokens are market sold in a single candle to retrieve as much SOL as possible from the locked liquidity pool
+4) The recovered SOL seeds the new LP paired with appropriate amount of tokens. Set market cap at or slightly below current market cap
+5) Claims open for 90 days - users burn MFTs and receive new tokens`, keywords: ["bonk", "bonkfun", "steps", "process", "how"], category: "process" },
+  { id: "migration-steps-pumpfun", question: "How does a migration work to Pump Fun?", answer: `Here's how the migration to Pump Fun works:
+1) Set up a new CA for pumpfun using MigrateFun creator dashboard (Ticker, CA, image)
+2) Users migrate their tokens in the migration portal for a specific time period
+3) Once migration ends, MigrateFun sells all migrated tokens
+4) MigrateFun takes all recovered SOL and buys out new token's bonding curve + purchases until it reaches old market cap levels
+5) Users return to migratefun and claim their new tokens
+6) 90-day claim period for all users, regardless if they migrated on time or late
+7) The claim period can also be used to swap tokens with centralized exchanges
+8) After 90 days, all unclaimed tokens and remaining SOL are returned to the team`, keywords: ["pump", "pumpfun", "steps", "process", "how"], category: "process" },
+  { id: "migration-steps-raydium", question: "How does Migrate Fun migrate tokens to Raydium?", answer: `1) The creator/team sets up a migration portal through migratefun.com - Create new CA (Ticker, name, image, supply) and set timeline period (1-30 days, 14 days average)
+2) After portal setup, holders commit their tokens to migration and get MFTs in exchange - tokens are locked in migration vault until time period ends
+3) Once migration ends, ALL old tokens are market sold in a single candle to retrieve as much SOL as possible
+4) The recovered SOL seeds the new LP paired with appropriate amount of new tokens. Market Cap is set by the user
+5) Claims open for 90 days - users burn MFTs and receive new tokens. Late migrators can swap at discounted rate
+6) At the end of the 90 day claim window all remaining tokens can be claimed by the team`, keywords: ["raydium", "steps", "process", "how"], category: "process" },
+  { id: "post-migration-checklist", question: "What are the steps I need to do after the migration?", answer: `Admin Checklist - places to register your new CA:
+
+PRIMARY:
+- Coingecko (Free + migration application process)
+- Dexscreener ($300)
+- GeckoTerminal (free for 5 days wait)
+- Holderscan (Listing free, Verify $125)
+
+SECONDARY:
+- Solscan (if metadata updates needed)
+- CoinMarketCap ($5000 for immediate listing)
+- Dextools ($300 for verification)
+- Photon (2 SOL)
+- Cookie.fun (Free, DM needed) [For AI accounts]
+- Kaito (DM needed) [For AI accounts]
+
+Note: Coingecko and CoinMarketCap will ask for a post from official twitter with migration details and new CA.`, keywords: ["after", "post", "checklist", "listing", "dexscreener", "coingecko"], category: "post-migration" },
+  { id: "post-migration-approval", question: "Do we need to do anything after the migration ends?", answer: `Yes, the team needs to approve several steps in the migration portal including:
+1) Selling the migrated tokens into the old LP
+2) Setting the new market cap
+3) Opening the claim portal
+
+Video tutorial: https://www.youtube.com/watch?v=SjPN-1DnXtM`, keywords: ["after", "ends", "approve", "portal"], category: "post-migration" },
+  { id: "market-cap-setting", question: "What market cap should we set?", answer: `Set at or slightly below the ending market cap at migration. For example, if your ending market cap is $1 million, set it to around $950,000. This accounts for the fact you won't receive 1:1 liquidity from the old pool compared to the new pool, which is determined by migration participation.`, keywords: ["market cap", "marketcap", "set", "recommend"], category: "settings" },
+  { id: "migrate-fun-cost", question: "What does Migrate Fun cost?", answer: `Migrate Fun charges a flat 3.75% fee on the total SOL unlocked from the old Liquidity Pool. This fee is taken automatically during the migration process.`, keywords: ["cost", "fee", "price", "charge", "3.75", "percent"], category: "fees" },
+  { id: "claim-fees-bonk", question: "How does the team claim their fees on Bonk Fun?", answer: `Go to https://bonk.fun/creator-rewards to claim your creator fees.`, keywords: ["claim", "fees", "bonk", "creator", "rewards"], category: "fees" },
+  { id: "claim-fees-raydium", question: "How do I claim fees on Raydium?", answer: `You can claim fees from https://raydium.io/portfolio/ with the same wallet that set up the migration.`, keywords: ["claim", "fees", "raydium", "portfolio"], category: "fees" },
+  { id: "claim-fees-pumpfun", question: "How do I claim fees on Pump Fun?", answer: `Fees are paid automatically to the wallet used to set up the migration. Once migrated to PumpSwap you will receive creator rewards based on their Ascend Program. Details: https://pump.fun/docs/fees`, keywords: ["claim", "fees", "pump", "pumpfun", "automatic"], category: "fees" },
+  { id: "audit-info", question: "Has Migrate Fun been audited?", answer: `Yes. Migrate Fun was audited by Halborn, the same auditing firm used by the Solana Foundation.
+Audit: https://www.halborn.com/audits/emblem-vault/migratefun-8ad34b
+Announcement: https://x.com/HalbornSecurity/status/1978869642744811933`, keywords: ["audit", "audited", "security", "halborn", "safe"], category: "security" },
+  { id: "user-experience", question: "What is the process like for the user?", answer: `Super easy - takes less than 20 seconds.
+1) During migration: users swap old tokens for Migrate Fun Tokens (MFTs)
+2) Once migration ends: claim period opens for 90 days, users burn MFTs to claim new tokens
+3) Late migrators: can swap old tokens for new at a discounted rate set by the team
+
+Video guides:
+- Migration: https://x.com/MigrateFun/status/1971259552856408433
+- Claims: https://x.com/MigrateFun/status/1976376597906325767`, keywords: ["user", "experience", "process", "simple", "easy"], category: "user-experience" },
+  { id: "what-is-migrate-fun", question: "What is Migrate Fun?", answer: `Migrate Fun is the category-defining platform that created the migration meta. It allows users to migrate locked liquidity from one launchpad to another.
+
+As of October 2025: 15 migrations completed, $5+ million in liquidity moved, largest migration was $35M market cap project. Supports migrations to Bonk Fun, Raydium, and Pump Fun.
+
+Links:
+- Website: https://migrate.fun/
+- X: https://x.com/MigrateFun
+- Docs: https://github.com/EmblemCompany/Migrate-fun-docs/
+- Audit: https://www.halborn.com/audits/emblem-vault/migratefun-8ad34b
+- Calculator: https://migrate.fun/migration-calculator`, keywords: ["what", "migrate fun", "about", "general", "overview"], category: "general" },
+  { id: "sol-recovery-estimate", question: "How can I see how much SOL we can get from the old LP?", answer: `Use the migration calculator to estimate SOL recovery based on participation percentages: https://migrate.fun/migration-calculator`, keywords: ["sol", "recovery", "estimate", "calculator", "liquidity", "how much"], category: "tools" },
+  { id: "documentation", question: "Do you have documentation?", answer: `Yes, documentation is available at: https://github.com/EmblemCompany/Migrate-fun-docs/`, keywords: ["documentation", "docs", "guide", "help"], category: "general" },
+  { id: "rebrand", question: "What if I want to rebrand?", answer: `The migration enables a full rebrand - reset metadata, image, logo, name, everything. Or keep it all the same if you prefer.`, keywords: ["rebrand", "change", "name", "logo", "image", "metadata"], category: "features" },
+  { id: "sniper-protection", question: "How do you prevent snipers when migrating to Pump Fun?", answer: `On Solana you can stack transactions. When deploying the bonding curve, you are first to purchase so you can buyout the bonding curve and more in the first transaction, preventing snipers.`, keywords: ["sniper", "snipers", "protection", "front-run", "mev"], category: "security" },
+  { id: "claim-period-flexibility", question: "Is there flexibility on the 90 day claim period?", answer: `The 90-day claim period is mandatory. Reasons:
+- All users need time to claim tokens after migration
+- Those who missed migration need a window
+- Users don't get tokens until after migration completes
+- Allowing team to withdraw during claims would be risky (potential rug)`, keywords: ["90 day", "claim", "period", "flexibility", "change"], category: "settings" },
+  { id: "migration-duration", question: "How long is the migration?", answer: `You can set the migration window for as long as you'd like. Average is 14 days. Some teams choose 7 days (works great), some go up to 30 days.
+
+Note: Majority of participation happens in the first and last 24 hours. Example: 76% participation with 50%+ migrating in first 24 hours and additional 10% on the last day.`, keywords: ["how long", "duration", "time", "days", "period", "window"], category: "settings" },
+  { id: "migration-performance", question: "Can you give examples of token performance after migration?", answer: `Migration squeeze: When large percentage of old tokens migrate, sell pressure reduces, often causing market cap spike near migration end.
+
+Example charts:
+- ZERA Old: https://dexscreener.com/solana/95at5r4i85gfqeew2yr6byfg8rlry1d9ztps7qrskdvc
+  New: https://dexscreener.com/solana/nn9vmhjtqgg9l9f8sp3geufwc5zvuhradcwehh7n7di
+- HUSTLE Old: https://dexscreener.com/solana/gjckb2eesjk65nuvpaw4tn2rabnr8wmfcwcwpagk5dzs
+  New: https://dexscreener.com/solana/hxo1wrcrdewek8l2j6rxswnolumej2mweh38gajxtw7y
+
+Thread: https://x.com/jakegallen_/status/1973051293213028468`, keywords: ["performance", "charts", "example", "before", "after", "squeeze"], category: "examples" },
+  { id: "why-migrate", question: "Why would teams want to migrate?", answer: `Top reasons:
+- Access to creator rewards
+- Rebrand opportunity
+- Fresh chart
+- Reclaim part of the token supply
+- Reinvigorated community on the other side`, keywords: ["why", "reasons", "benefits", "advantages", "should"], category: "general" },
+  { id: "migration-recommendation-steps", question: "What steps do you recommend when considering a migration?", answer: `1) Discuss with Migrate Fun team: process details, where to move LP (Raydium, Bonk Fun, or Pump Fun)
+2) Discuss benefits with your community, especially whale holders - get buy-in
+3) Announce on all social channels - maximize awareness for maximum participation`, keywords: ["recommend", "steps", "considering", "planning", "prepare"], category: "process" },
+  { id: "multiple-wallets", question: "Do holders with multiple wallets need to consolidate?", answer: `No. Migration is linear - users can migrate all tokens together or separately. Makes no difference.`, keywords: ["multiple", "wallets", "consolidate", "separate"], category: "user-experience" },
+  { id: "mft-value", question: "Do MFTs show value in wallets?", answer: `MFTs (Migrate Fun Tokens) are just placeholder tokens for the migration. They are valueless.`, keywords: ["mft", "migrate fun tokens", "value", "placeholder"], category: "user-experience" },
+  { id: "announcement-examples", question: "Can you give me sample migration announcements?", answer: `Here are announcements made by teams:
+- https://x.com/radrdotfun/status/1952127168101949620
+- https://x.com/project_89/status/1951345024656089368
+- https://x.com/HKittyOnSol/status/1948925330032349210
+- https://x.com/ModernStoicAI/status/1948129627362218483
+- https://x.com/pokithehamster/status/1950238636928327927
+- https://x.com/IQ6900_/status/1953002036599173499
+- https://x.com/TheBongoCat/status/1965538945132843333`, keywords: ["announcement", "sample", "example", "post", "twitter"], category: "examples" },
+  { id: "graphics", question: "Does Migrate Fun provide graphics for announcements?", answer: `No. For your own migration announcement you create the graphic. Migrate Fun's designer creates group migration announcements only.`, keywords: ["graphics", "images", "design", "announcement"], category: "general" },
+  { id: "developer-required", question: "Do I need to be a developer to migrate?", answer: `No development required. The entire process is a few clicks for both pre-migration and post-migration.`, keywords: ["developer", "technical", "coding", "code"], category: "general" },
+  { id: "exchange-tokens", question: "What happens to tokens on exchanges or locked in Streamflow?", answer: `They will miss the migration as those tokens are considered circulating supply onchain. Options:
+1) Join as late migrator during 90-day claim window
+2) After 90-day period, team takes possession of unclaimed tokens and can reimburse directly`, keywords: ["exchange", "streamflow", "locked", "vested", "cex"], category: "edge-cases" },
+  { id: "unclaimed-tokens", question: "Can we get unclaimed tokens?", answer: `After the 90-day claim period ends, all unclaimed tokens are returned to whichever wallet set up the migration (the team).`, keywords: ["unclaimed", "supply", "remaining", "tokens", "team"], category: "post-migration" },
+  { id: "participation-rate", question: "What is typical participation percentage?", answer: `Nearly all projects have had over 50% migration participation. View all stats at https://migrate.fun/projects`, keywords: ["participation", "percentage", "rate", "typical", "average"], category: "statistics" },
+  { id: "late-penalty", question: "What penalty can teams set for late migrators?", answer: `Teams can set 0-100% penalty for late migrators who swap during the 90-day claim window. 25% seems to be a good balance - encourages participation without being overly punishing.`, keywords: ["penalty", "late", "discount", "punish", "percent"], category: "settings" },
+  { id: "new-ca", question: "Will we get a new CA or just change the pair?", answer: `A new CA. If migrating to Bonk Fun your CA will end with "bonk". If migrating to Pump Fun it will end with "pump".`, keywords: ["ca", "contract", "address", "new", "pair"], category: "process" },
+  { id: "vanity-ca", question: "Can we create a vanity CA?", answer: `Yes, but if migrating to Bonk Fun it needs to end with "bonk", or for Pump Fun it needs to end with "pump".`, keywords: ["vanity", "ca", "custom", "address", "contract"], category: "features" },
+  { id: "vested-tokens", question: "What about team tokens locked with Streamflow?", answer: `Those tokens can't be migrated. They won't be lost - you'll recapture that supply post-migration. Any unmigrated tokens return to team at full or discounted rate depending on your late migrator penalty setting.`, keywords: ["vested", "streamflow", "locked", "team"], category: "edge-cases" },
+  { id: "wallet-tracking", question: "Can I track wallet addresses post-migration?", answer: `At the end of migration, there's a snapshot tool that lets you download a CSV of all wallets holding the old token.`, keywords: ["wallet", "track", "snapshot", "csv", "addresses"], category: "tools" },
+  { id: "old-listings", question: "What happens to old token listings?", answer: `You will need to apply to new directories. Migrate Fun provides a list once you begin the migration process.`, keywords: ["listings", "directories", "old", "new", "update"], category: "post-migration" },
+  { id: "lp-locking", question: "Does the new LP get locked?", answer: `If migrating to Bonk Fun or Pump Fun: LP is locked (their rules). If migrating to Raydium: LP is unlocked and you control it.`, keywords: ["lp", "locked", "liquidity", "pool", "control"], category: "process" },
+  { id: "sol-pairs", question: "Are Bonk migrations confined to SOL pairs?", answer: `As of October 2025, they are SOL migrations. Check with the team to see if USD1 pairs are possible.`, keywords: ["sol", "pair", "usd1", "usdc", "bonk"], category: "settings" },
+  { id: "change-penalty", question: "Can I change the penalty after setup?", answer: `No. The penalty must be set during migration creation and cannot be changed after.`, keywords: ["change", "penalty", "modify", "update", "after"], category: "settings" },
+  { id: "unhappy-holders", question: "What if someone is unhappy about the migration?", answer: `They can sell their tokens and not participate. Migrations are a fresh start - holders who migrate are voting with their tokens that they support the team and believe in the project's future.`, keywords: ["unhappy", "disagree", "against", "sell"], category: "user-experience" },
+  { id: "sample-announcement", question: "What is a good announcement template?", answer: `Sample for Bonk Fun migration:
+
+"We're excited to announce that we're migrating with @MigrateFun and officially joining the @bonk_inu ecosystem next month!
+
+With our 1-year anniversary less than a month away, this migration to @bonk_fun marks the beginning of our next chapter.
+
+Why Bonk Fun?
+\u{1F9F0} Purpose-built tools for community projects
+\u{1F4B8} Transaction fee rev share
+\u{1F501} Seamless LP migration
+\u{1F91D} Strategic alignment with top meme coin teams
+
+Our migration timeline + holder instructions drop soon."`, keywords: ["announcement", "template", "sample", "post"], category: "examples" },
+  { id: "share-link", question: "Do you have a link to share explaining Migrate Fun?", answer: `Overview thread: https://x.com/migratefun/status/1957492884355314035
+Deep dive docs: https://github.com/EmblemCompany/Migrate-fun-docs/`, keywords: ["link", "share", "explain", "overview"], category: "general" },
+  { id: "exchange-rate", question: "Is the exchange rate always 1:1?", answer: `Yes, 1 old token = 1 new token for users who participate in migration. Users who miss can swap during the 90-day claim window at a discounted rate set by the team.`, keywords: ["exchange", "rate", "1:1", "ratio", "same"], category: "process" },
+  { id: "change-supply", question: "Can I change the total supply?", answer: `Generally yes, with some constraints depending on destination platform. Reach out to Migrate Fun team to discuss specifics.`, keywords: ["supply", "change", "total", "amount"], category: "features" },
+  { id: "contact", question: "How can I get in touch with the Migrate Fun team?", answer: `Send a direct message to the Migrate Fun X account: https://x.com/MigrateFun`, keywords: ["contact", "reach", "touch", "dm", "message", "talk"], category: "general" },
+  { id: "ready-to-migrate", question: "I am ready to migrate, what is next?", answer: `Send a direct message to the Migrate Fun X account: https://x.com/MigrateFun`, keywords: ["ready", "start", "begin", "next"], category: "general" },
+  { id: "risks", question: "What are the risks of migrating?", answer: `Main risk: Failed migration where not enough tokens migrate to fund the new LP. In that case, migrated tokens are sold into the old LP and SOL is returned to community members who participated.`, keywords: ["risk", "danger", "fail", "problem", "issue"], category: "security" },
+  { id: "how-detect-non-migrators", question: "How does Migrate Fun know who did not migrate?", answer: `Migrate Fun has a snapshot and claim tool that puts onchain all wallets holding old tokens at migration end. This enables late migrators to swap old tokens for new during the 90-day claim window at the team-set discount.`, keywords: ["snapshot", "detect", "know", "non-migrators"], category: "tools" },
+  { id: "no-penalty", question: "What if I do not want to penalize non-migrators?", answer: `Set the late claim penalty to zero. Holders who didn't migrate can then swap old tokens for new at a 1:1 rate during the 90-day claim window.`, keywords: ["no penalty", "zero", "fair"], category: "settings" },
+  { id: "missed-claim-window", question: "What happens if holders miss both migration and claim window?", answer: `They won't have access to new tokens through Migrate Fun platform. All remaining tokens go to the team after 90-day window closes. The team has a snapshot of all old token holders and can handle at their discretion.`, keywords: ["missed", "both", "claim", "window", "late"], category: "edge-cases" },
+  { id: "exchange-options", question: "What options do exchanges have to swap tokens?", answer: `Two options:
+
+Option 1: Participate onchain through the migration portal (same as retail). Load tokens into Phantom wallet, migrate, then claim. ~10 seconds each step.
+
+Option 2: Admin withdraw function during 90-day claim period. Migration admin can withdraw new tokens from claims vault and manually swap with exchange.
+- 90-day window for exchange procedures
+- Exchange can observe migration complete before acting
+- Can receive new tokens before sending old
+- Can pause trading during process`, keywords: ["exchange", "cex", "swap", "options", "centralized"], category: "edge-cases" },
+  { id: "buy-prevent-dump", question: "Can we buy supply before migration to prevent dumping?", answer: `I would recommend buying now. There is no arb opportunity as you set the market cap of the new token.
+
+To regain control of non-migrated tokens, you can penalize non-migrators. Example: If 60% migrate, 40% didn't. With a 50% penalty on non-migrators, you'd recoup 20% of total supply if everyone claimed.`, keywords: ["buy", "dump", "supply", "control", "arb"], category: "strategy" }
+];
+var migrateFunPlugin = {
+  name: "migrate-fun-knowledge",
+  version: "1.0.0",
+  description: "Search Migrate.fun knowledge base for token migration answers",
+  tools: [
+    {
+      name: "search_migrate_fun_docs",
+      description: "Search the Migrate.fun knowledge base for answers about token migrations. Use this tool when users ask about: how migrations work (Bonk Fun, Pump Fun, Raydium), costs/fees/timelines, post-migration steps, user experience, technical details (LP, CA, penalties), or examples. Returns ranked Q&A pairs from real support conversations.",
+      parameters: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "The search query - user question or key terms about token migrations"
+          },
+          topK: {
+            type: "number",
+            description: "Number of results to return (default: 5, max: 10)"
+          }
+        },
+        required: ["query"]
+      }
+    }
+  ],
+  executors: {
+    search_migrate_fun_docs: async (args2) => {
+      const query = args2.query;
+      const topK = Math.min(Math.max(1, args2.topK || 5), 10);
+      const queryLower = query.toLowerCase();
+      const queryWords = queryLower.split(/\s+/).filter((w) => w.length > 2);
+      const scored = QA.map((qa) => {
+        let score = 0;
+        const questionLower = qa.question.toLowerCase();
+        const answerLower = qa.answer.toLowerCase();
+        const keywordsStr = qa.keywords.join(" ").toLowerCase();
+        const fullText = `${questionLower} ${answerLower} ${keywordsStr}`;
+        if (questionLower.includes(queryLower)) score += 15;
+        if (fullText.includes(queryLower)) score += 8;
+        for (const word of queryWords) {
+          if (qa.keywords.some((kw) => kw.toLowerCase().includes(word) || word.includes(kw.toLowerCase()))) {
+            score += 4;
+          }
+          if (questionLower.includes(word)) score += 3;
+          if (answerLower.includes(word)) score += 1;
+        }
+        return { ...qa, score };
+      });
+      const results = scored.filter((qa) => qa.score > 0).sort((a, b) => b.score - a.score).slice(0, topK).map((qa, i) => ({
+        rank: i + 1,
+        relevance: Math.round(qa.score / 30 * 100) / 100,
+        question: qa.question,
+        answer: qa.answer,
+        category: qa.category
+      }));
+      return {
+        success: true,
+        query,
+        resultCount: results.length,
+        results,
+        hint: results.length === 0 ? "No matches found. Suggest contacting @MigrateFun on X: https://x.com/MigrateFun" : "Use these Q&A pairs to answer. Include relevant links from the answers."
+      };
+    }
+  },
+  hooks: {
+    onRegister: () => {
+      console.log("[Plugin] Migrate.fun Knowledge Base v1.0.0 registered");
+    }
+  }
+};
+
+// src/plugins/piiProtection.ts
+var TOKEN_MAP_KEY = "__piiTokenMaps";
+var PERSISTENT_MAP_KEY = "__piiPersistentMap";
+function getTokenMaps() {
+  const storage = typeof window !== "undefined" ? window : global;
+  if (!storage[TOKEN_MAP_KEY]) {
+    storage[TOKEN_MAP_KEY] = /* @__PURE__ */ new Map();
+  }
+  return storage[TOKEN_MAP_KEY];
+}
+function getPersistentMap() {
+  const storage = typeof window !== "undefined" ? window : global;
+  if (!storage[PERSISTENT_MAP_KEY]) {
+    storage[PERSISTENT_MAP_KEY] = {
+      piiToToken: /* @__PURE__ */ new Map(),
+      tokenToPii: /* @__PURE__ */ new Map(),
+      counter: { value: 0 }
+    };
+  }
+  return storage[PERSISTENT_MAP_KEY];
+}
+var piiProtectionPlugin = {
+  name: "pii-protection",
+  version: "1.0.0",
+  description: "Tokenizes PII before sending to AI, restores in responses",
+  tools: [],
+  executors: {},
+  hooks: {
+    onRegister: () => {
+      console.log("[PII Protection] Plugin registered - PII will be tokenized in requests");
+    },
+    beforeRequest: (request) => {
+      const maps = getTokenMaps();
+      const persistent = getPersistentMap();
+      const requestId = Date.now().toString();
+      const requestTokenMap = /* @__PURE__ */ new Map();
+      const tokenize = (text) => {
+        if (typeof text !== "string") return text;
+        return text.replace(/\b\d{3}-\d{2}-\d{4}\b/g, (match) => {
+          if (persistent.piiToToken.has(match)) {
+            const existingToken = persistent.piiToToken.get(match);
+            requestTokenMap.set(existingToken, match);
+            return existingToken;
+          }
+          const token = `{{SSN_${++persistent.counter.value}}}`;
+          persistent.piiToToken.set(match, token);
+          persistent.tokenToPii.set(token, match);
+          requestTokenMap.set(token, match);
+          return token;
+        }).replace(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/gi, (match) => {
+          if (persistent.piiToToken.has(match)) {
+            const existingToken = persistent.piiToToken.get(match);
+            requestTokenMap.set(existingToken, match);
+            return existingToken;
+          }
+          const token = `{{EMAIL_${++persistent.counter.value}}}`;
+          persistent.piiToToken.set(match, token);
+          persistent.tokenToPii.set(token, match);
+          requestTokenMap.set(token, match);
+          return token;
+        }).replace(/\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}/g, (match) => {
+          if (persistent.piiToToken.has(match)) {
+            const existingToken = persistent.piiToToken.get(match);
+            requestTokenMap.set(existingToken, match);
+            return existingToken;
+          }
+          const token = `{{PHONE_${++persistent.counter.value}}}`;
+          persistent.piiToToken.set(match, token);
+          persistent.tokenToPii.set(token, match);
+          requestTokenMap.set(token, match);
+          return token;
+        }).replace(/\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b/g, (match) => {
+          if (persistent.piiToToken.has(match)) {
+            const existingToken = persistent.piiToToken.get(match);
+            requestTokenMap.set(existingToken, match);
+            return existingToken;
+          }
+          const token = `{{CARD_${++persistent.counter.value}}}`;
+          persistent.piiToToken.set(match, token);
+          persistent.tokenToPii.set(token, match);
+          requestTokenMap.set(token, match);
+          return token;
+        });
+      };
+      const anonymizedMessages = request.messages.map((msg) => ({
+        ...msg,
+        content: typeof msg.content === "string" ? tokenize(msg.content) : msg.content
+      }));
+      if (requestTokenMap.size > 0) {
+        maps.set(requestId, requestTokenMap);
+        console.log(`[PII Protection] Tokenized ${requestTokenMap.size} PII values`);
+      }
+      return { ...request, messages: anonymizedMessages };
+    },
+    afterResponse: (response) => {
+      const persistent = getPersistentMap();
+      if (typeof response.content === "string") {
+        let restored = response.content;
+        let restoredCount = 0;
+        for (const [token, original] of persistent.tokenToPii.entries()) {
+          if (restored.includes(token)) {
+            restored = restored.split(token).join(original);
+            restoredCount++;
+          }
+        }
+        if (restoredCount > 0) {
+          response.content = restored;
+          console.log(`[PII Protection] Restored ${restoredCount} PII values`);
+        }
+      }
+    }
+  }
+};
+
+// src/plugins/userQuestion.ts
+function ensureModalStyles() {
+  if (typeof document === "undefined") return;
+  const styleId = "user-question-modal-styles";
+  if (document.getElementById(styleId)) return;
+  const styles = document.createElement("style");
+  styles.id = styleId;
+  styles.textContent = `
+    .user-question-overlay {
+      position: fixed;
+      top: 0;
+      left: 0;
+      right: 0;
+      bottom: 0;
+      background: rgba(0, 0, 0, 0.6);
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      z-index: 10000;
+      animation: uqFadeIn 0.2s ease-out;
+    }
+
+    @keyframes uqFadeIn {
+      from { opacity: 0; }
+      to { opacity: 1; }
+    }
+
+    .user-question-modal {
+      background: #1a1a2e;
+      border: 1px solid #333;
+      border-radius: 12px;
+      padding: 24px;
+      max-width: 480px;
+      width: 90%;
+      box-shadow: 0 20px 60px rgba(0, 0, 0, 0.4);
+      animation: uqSlideUp 0.2s ease-out;
+    }
+
+    @keyframes uqSlideUp {
+      from { transform: translateY(20px); opacity: 0; }
+      to { transform: translateY(0); opacity: 1; }
+    }
+
+    .user-question-title {
+      font-size: 18px;
+      font-weight: 600;
+      color: #fff;
+      margin: 0 0 16px 0;
+    }
+
+    .user-question-choices {
+      display: flex;
+      flex-direction: column;
+      gap: 8px;
+      margin-bottom: 20px;
+    }
+
+    .user-question-choice {
+      display: flex;
+      align-items: center;
+      gap: 12px;
+      padding: 12px 16px;
+      background: #252540;
+      border: 1px solid #333;
+      border-radius: 8px;
+      cursor: pointer;
+      transition: all 0.15s ease;
+    }
+
+    .user-question-choice:hover {
+      background: #2a2a4a;
+      border-color: #4a4a6a;
+    }
+
+    .user-question-choice.selected {
+      background: #2a3a5a;
+      border-color: #4a7aff;
+    }
+
+    .user-question-choice input {
+      margin: 0;
+      accent-color: #4a7aff;
+    }
+
+    .user-question-choice label {
+      flex: 1;
+      color: #e0e0e0;
+      cursor: pointer;
+      font-size: 14px;
+    }
+
+    .user-question-actions {
+      display: flex;
+      gap: 12px;
+      justify-content: flex-end;
+    }
+
+    .user-question-btn {
+      padding: 10px 20px;
+      border-radius: 6px;
+      font-size: 14px;
+      font-weight: 500;
+      cursor: pointer;
+      transition: all 0.15s ease;
+    }
+
+    .user-question-btn-cancel {
+      background: transparent;
+      border: 1px solid #444;
+      color: #aaa;
+    }
+
+    .user-question-btn-cancel:hover {
+      background: #333;
+      color: #fff;
+    }
+
+    .user-question-btn-submit {
+      background: #4a7aff;
+      border: none;
+      color: #fff;
+    }
+
+    .user-question-btn-submit:hover {
+      background: #5a8aff;
+    }
+
+    .user-question-btn-submit:disabled {
+      background: #333;
+      color: #666;
+      cursor: not-allowed;
+    }
+  `;
+  document.head.appendChild(styles);
+}
+var askUserTool = {
+  name: "ask_user",
+  description: `Ask the user a multiple choice question and wait for their response. Use this when you need user input to proceed - for example: clarifying requirements, getting preferences, or confirming actions. The tool blocks until the user responds.`,
+  parameters: {
+    type: "object",
+    properties: {
+      question: {
+        type: "string",
+        description: "The question to ask the user"
+      },
+      choices: {
+        type: "array",
+        items: { type: "string" },
+        description: "Array of choices to present (2-6 options recommended)"
+      },
+      allowMultiple: {
+        type: "boolean",
+        description: "If true, user can select multiple choices. Default: false"
+      }
+    },
+    required: ["question", "choices"]
+  }
+};
+var askUserExecutor = async (args2) => {
+  const { question, choices, allowMultiple = false } = args2;
+  if (!question || !choices || !Array.isArray(choices) || choices.length === 0) {
+    return {
+      question: question || "",
+      selectedChoices: [],
+      answered: false
+    };
+  }
+  if (typeof document === "undefined") {
+    console.log(`[User Question] Question: ${question}`);
+    console.log(`[User Question] Choices: ${choices.join(", ")}`);
+    return {
+      question,
+      selectedChoices: [choices[0]],
+      answered: true
+    };
+  }
+  ensureModalStyles();
+  return new Promise((resolve) => {
+    const selected = /* @__PURE__ */ new Set();
+    const overlay = document.createElement("div");
+    overlay.className = "user-question-overlay";
+    const modal = document.createElement("div");
+    modal.className = "user-question-modal";
+    const title = document.createElement("h3");
+    title.className = "user-question-title";
+    title.textContent = question;
+    modal.appendChild(title);
+    const choicesDiv = document.createElement("div");
+    choicesDiv.className = "user-question-choices";
+    const inputType = allowMultiple ? "checkbox" : "radio";
+    const inputName = `uq-${Date.now()}`;
+    choices.forEach((choice, index) => {
+      const choiceDiv = document.createElement("div");
+      choiceDiv.className = "user-question-choice";
+      const input = document.createElement("input");
+      input.type = inputType;
+      input.name = inputName;
+      input.id = `${inputName}-${index}`;
+      input.value = choice;
+      const label = document.createElement("label");
+      label.htmlFor = input.id;
+      label.textContent = choice;
+      choiceDiv.appendChild(input);
+      choiceDiv.appendChild(label);
+      const handleSelect = () => {
+        if (allowMultiple) {
+          if (selected.has(choice)) {
+            selected.delete(choice);
+            choiceDiv.classList.remove("selected");
+          } else {
+            selected.add(choice);
+            choiceDiv.classList.add("selected");
+          }
+        } else {
+          selected.clear();
+          selected.add(choice);
+          choicesDiv.querySelectorAll(".user-question-choice").forEach((c) => c.classList.remove("selected"));
+          choiceDiv.classList.add("selected");
+        }
+        updateSubmitButton();
+      };
+      input.addEventListener("change", handleSelect);
+      choiceDiv.addEventListener("click", (e) => {
+        if (e.target !== input) {
+          input.checked = !input.checked || !allowMultiple;
+          handleSelect();
+        }
+      });
+      choicesDiv.appendChild(choiceDiv);
+    });
+    modal.appendChild(choicesDiv);
+    const actions = document.createElement("div");
+    actions.className = "user-question-actions";
+    const cancelBtn = document.createElement("button");
+    cancelBtn.className = "user-question-btn user-question-btn-cancel";
+    cancelBtn.textContent = "Skip";
+    cancelBtn.onclick = () => {
+      cleanup();
+      resolve({
+        question,
+        selectedChoices: [],
+        answered: false
+      });
+    };
+    const submitBtn = document.createElement("button");
+    submitBtn.className = "user-question-btn user-question-btn-submit";
+    submitBtn.textContent = "Submit";
+    submitBtn.disabled = true;
+    submitBtn.onclick = () => {
+      cleanup();
+      resolve({
+        question,
+        selectedChoices: Array.from(selected),
+        answered: true
+      });
+    };
+    const updateSubmitButton = () => {
+      submitBtn.disabled = selected.size === 0;
+    };
+    actions.appendChild(cancelBtn);
+    actions.appendChild(submitBtn);
+    modal.appendChild(actions);
+    overlay.appendChild(modal);
+    document.body.appendChild(overlay);
+    const cleanup = () => {
+      overlay.remove();
+    };
+    const handleEscape = (e) => {
+      if (e.key === "Escape") {
+        document.removeEventListener("keydown", handleEscape);
+        cleanup();
+        resolve({
+          question,
+          selectedChoices: [],
+          answered: false
+        });
+      }
+    };
+    document.addEventListener("keydown", handleEscape);
+  });
+};
+var userQuestionPlugin = {
+  name: "user-question",
+  version: "1.0.0",
+  description: "Allows AI to ask users multiple choice questions via modal",
+  tools: [askUserTool],
+  executors: {
+    ask_user: askUserExecutor
+  },
+  hooks: {
+    onRegister: () => {
+      console.log("[User Question] Plugin registered - AI can now ask you questions");
+    }
+  }
+};
+
+// src/plugins/alert.ts
+var sendAlertTool = {
+  name: "send_alert",
+  description: "Display a browser alert popup with a message to the user",
+  parameters: {
+    type: "object",
+    properties: {
+      message: {
+        type: "string",
+        description: "The message to display in the alert popup"
+      }
+    },
+    required: ["message"]
+  }
+};
+var sendAlertExecutor = async (args2) => {
+  const message = args2.message;
+  if (typeof window === "undefined") {
+    console.log(`[Alert] ${message}`);
+    return { success: true, message, environment: "server" };
+  }
+  alert(message);
+  return { success: true, message };
+};
+var alertPlugin = {
+  name: "alert",
+  version: "1.0.0",
+  description: "Display browser alert popups",
+  tools: [sendAlertTool],
+  executors: {
+    send_alert: sendAlertExecutor
+  },
+  hooks: {
+    onRegister: () => {
+      console.log("[Alert] Plugin registered");
+    }
+  }
+};
+
+// src/plugins/jsExecutor.ts
+var executeJsTool = {
+  name: "execute_javascript",
+  description: `Execute JavaScript code in the browser and return the results. The code runs in the page context with access to DOM, window, localStorage, etc.
+
+IMPORTANT USAGE NOTES:
+- Use console.log() to output values that will be captured and returned
+- The last expression's value OR explicit return statement will be captured as 'returnValue'
+- All console.log calls are captured in the 'logs' array
+- For multi-line code, escape newlines or use semicolons: "const x = 1; const y = 2; console.log(x + y);"
+- Example: "const prices = [100, 200, 150]; const avg = prices.reduce((a,b) => a+b, 0) / prices.length; console.log('Average:', avg); return avg;"
+- Can access: document, window, localStorage, fetch, etc.`,
+  parameters: {
+    type: "object",
+    properties: {
+      code: {
+        type: "string",
+        description: "The JavaScript code to execute. Use console.log() for output and/or return a value."
+      }
+    },
+    required: ["code"]
+  }
+};
+var executeJsExecutor = async (args) => {
+  const code = args.code;
+  if (typeof window === "undefined") {
+    return {
+      success: false,
+      returnValue: null,
+      logs: [],
+      error: { message: "JavaScript execution requires browser environment" }
+    };
+  }
+  const logs = [];
+  const originalLog = console.log;
+  const originalWarn = console.warn;
+  const originalError = console.error;
+  console.log = (...logArgs) => {
+    logs.push({
+      type: "log",
+      args: logArgs.map((a) => typeof a === "object" ? JSON.stringify(a) : String(a))
+    });
+    originalLog.apply(console, logArgs);
+  };
+  console.warn = (...logArgs) => {
+    logs.push({
+      type: "warn",
+      args: logArgs.map((a) => typeof a === "object" ? JSON.stringify(a) : String(a))
+    });
+    originalWarn.apply(console, logArgs);
+  };
+  console.error = (...logArgs) => {
+    logs.push({
+      type: "error",
+      args: logArgs.map((a) => typeof a === "object" ? JSON.stringify(a) : String(a))
+    });
+    originalError.apply(console, logArgs);
+  };
+  let returnValue;
+  let error = null;
+  try {
+    const wrappedCode = "(async () => { " + code + " })()";
+    returnValue = await eval(wrappedCode);
+  } catch (e) {
+    const err = e;
+    error = { message: err.message, stack: err.stack };
+  } finally {
+    console.log = originalLog;
+    console.warn = originalWarn;
+    console.error = originalError;
+  }
+  return {
+    success: !error,
+    returnValue: returnValue !== void 0 ? typeof returnValue === "object" ? JSON.stringify(returnValue) : String(returnValue) : null,
+    logs,
+    error
+  };
+};
+var jsExecutorPlugin = {
+  name: "js-executor",
+  version: "1.0.0",
+  description: "Execute JavaScript code in the browser",
+  tools: [executeJsTool],
+  executors: {
+    execute_javascript: executeJsExecutor
+  },
+  hooks: {
+    onRegister: () => {
+      console.log("[JS Executor] Plugin registered - AI can now execute JavaScript");
+    }
+  }
+};
+
+// src/plugins/screenshot.ts
+var screenshotTool = {
+  name: "take_screenshot",
+  description: `Take a screenshot of the current page and upload it. Returns the URL of the uploaded image that can be used in conversation or for analysis.
+
+The screenshot captures the visible viewport of the page. The image is uploaded to the server and a permanent URL is returned.
+
+Use this when:
+- User asks to see what's on their screen
+- You need to analyze the current page visually
+- User wants to share/save the current view`,
+  parameters: {
+    type: "object",
+    properties: {
+      selector: {
+        type: "string",
+        description: "Optional CSS selector to capture a specific element instead of the full page. Leave empty for full page screenshot."
+      }
+    }
+  }
+};
+var screenshotExecutor = async (args2) => {
+  const selector = args2.selector;
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return {
+      success: false,
+      error: "Screenshot requires browser environment"
+    };
+  }
+  try {
+    if (!window.html2canvas) {
+      await new Promise((resolve, reject) => {
+        const script = document.createElement("script");
+        script.src = "https://cdnjs.cloudflare.com/ajax/libs/html2canvas/1.4.1/html2canvas.min.js";
+        script.onload = () => resolve();
+        script.onerror = () => reject(new Error("Failed to load html2canvas"));
+        document.head.appendChild(script);
+      });
+    }
+    const target = selector ? document.querySelector(selector) : document.body;
+    if (!target) {
+      return { success: false, error: "Element not found: " + selector };
+    }
+    const canvas = await window.html2canvas(target, {
+      useCORS: true,
+      allowTaint: true,
+      backgroundColor: "#000000",
+      scale: 1
+    });
+    const blob = await new Promise((resolve) => {
+      canvas.toBlob(resolve, "image/png", 0.9);
+    });
+    if (!blob) {
+      return { success: false, error: "Failed to create image blob" };
+    }
+    const formData = new FormData();
+    formData.append("file", blob, "screenshot-" + Date.now() + ".png");
+    const response = await fetch("/api/files/upload", {
+      method: "POST",
+      body: formData
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      return { success: false, error: errorData.error || "Upload failed" };
+    }
+    const data = await response.json();
+    return {
+      success: true,
+      url: data.url,
+      contentType: data.contentType,
+      message: "Screenshot captured and uploaded successfully"
+    };
+  } catch (e) {
+    const err = e;
+    return {
+      success: false,
+      error: err.message || "Screenshot failed"
+    };
+  }
+};
+var screenshotPlugin = {
+  name: "screenshot",
+  version: "1.0.0",
+  description: "Take screenshots of the current page",
+  tools: [screenshotTool],
+  executors: {
+    take_screenshot: screenshotExecutor
+  },
+  hooks: {
+    onRegister: () => {
+      console.log("[Screenshot] Plugin registered - AI can now take screenshots");
+    }
+  }
+};
+
+// src/plugins/index.ts
+var availablePlugins = [
+  {
+    ...predictionMarketPlugin,
+    description: "Search and analyze Polymarket and Kalshi prediction markets"
+  },
+  {
+    ...migrateFunPlugin,
+    description: "Search Migrate.fun knowledge base for token migration answers"
+  },
+  {
+    ...piiProtectionPlugin,
+    description: "Tokenizes PII before sending to AI, restores in responses"
+  },
+  {
+    ...userQuestionPlugin,
+    description: "Allows AI to ask users multiple choice questions via modal"
+  },
+  {
+    ...alertPlugin,
+    description: "Display browser alert popups"
+  },
+  {
+    ...jsExecutorPlugin,
+    description: "Execute JavaScript code in the browser"
+  },
+  {
+    ...screenshotPlugin,
+    description: "Take screenshots of the current page"
+  }
+];
+function getAvailablePlugin(name) {
+  return availablePlugins.find((p) => p.name === name);
+}
+
+export { alertPlugin, availablePlugins, getAvailablePlugin, jsExecutorPlugin, migrateFunPlugin, piiProtectionPlugin, predictionMarketPlugin, screenshotPlugin, userQuestionPlugin };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map