@fload-ai/mcp 0.1.1 → 0.2.1

package/dist/tools/index.js

@@ -0,0 +1,1952 @@
+// src/rate-limiter.ts
+var RateLimiter = class {
+  constructor(maxCalls = 100, windowMs = 6e4) {
+    this.maxCalls = maxCalls;
+    this.windowMs = windowMs;
+  }
+  calls = /* @__PURE__ */ new Map();
+  check(key) {
+    const now = Date.now();
+    const windowStart = now - this.windowMs;
+    let timestamps = this.calls.get(key) || [];
+    timestamps = timestamps.filter((t) => t > windowStart);
+    if (timestamps.length >= this.maxCalls) {
+      const oldestInWindow = timestamps[0];
+      const retryAfterMs = oldestInWindow + this.windowMs - now;
+      this.calls.set(key, timestamps);
+      return { allowed: false, remaining: 0, retryAfterMs };
+    }
+    timestamps.push(now);
+    this.calls.set(key, timestamps);
+    return {
+      allowed: true,
+      remaining: this.maxCalls - timestamps.length,
+      retryAfterMs: 0
+    };
+  }
+};
+
+// src/tools/apps.ts
+import { z } from "zod";
+
+// src/lib/format.ts
+function formatAsJson(data) {
+  return JSON.stringify(data, null, 2);
+}
+function formatError(error) {
+  if (error instanceof Error) {
+    return `Error: ${error.message}`;
+  }
+  return `Unknown error: ${String(error)}`;
+}
+
+// src/tools/apps.ts
+var listAppsSchema = z.object({
+  platform: z.enum(["ios", "android"]).optional().describe("Filter by platform (ios or android)"),
+  limit: z.number().int().min(1).max(100).default(50).describe("Maximum number of apps to return")
+});
+var getAppDetailsSchema = z.object({
+  assetId: z.string().uuid().optional().describe("App UUID from Fload database"),
+  bundleId: z.string().optional().describe("App bundle ID (e.g., com.example.app)")
+});
+async function listApps(input, client) {
+  try {
+    const response = await client.get("/api/assets", {
+      limit: input.limit,
+      offset: 0
+    });
+    const apps = response.data || [];
+    const filtered = input.platform ? apps.filter((app) => {
+      if (input.platform === "ios")
+        return !!app.appleAppId;
+      if (input.platform === "android")
+        return !!app.googleAppId;
+      return true;
+    }) : apps;
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson({
+            total: filtered.length,
+            apps: filtered.map((app) => ({
+              id: app.id,
+              name: app.name,
+              bundleId: app.bundleId,
+              platform: app.appleAppId ? "ios" : app.googleAppId ? "android" : "unknown",
+              addedAt: app.updatedAt || app.createdAt
+            }))
+          })
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function getAppDetails(input, client) {
+  try {
+    if (!input.assetId && !input.bundleId) {
+      throw new Error("Either assetId or bundleId must be provided");
+    }
+    let assetId = input.assetId;
+    if (!assetId && input.bundleId) {
+      const allApps = await client.get("/api/assets", { limit: 100, offset: 0 });
+      const match = (allApps.data || []).find((a) => a.bundleId === input.bundleId);
+      if (!match) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "App not found with that bundle ID"
+            }
+          ],
+          isError: true
+        };
+      }
+      assetId = match.id;
+    }
+    const response = await client.get(`/api/assets/${assetId}`);
+    const app = response.data || response;
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson({
+            id: app.id,
+            name: app.name,
+            bundleId: app.bundleId,
+            appleAppId: app.appleAppId,
+            googleAppId: app.googleAppId,
+            platform: app.appleAppId ? "ios" : app.googleAppId ? "android" : "unknown",
+            currentValuation: app.currentValuation,
+            metadata: app.metadata,
+            addedAt: app.createdAt,
+            updatedAt: app.updatedAt
+          })
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/tools/reviews.ts
+import { z as z2 } from "zod";
+var getReviewsSchema = z2.object({
+  assetId: z2.string().uuid().optional().describe("App UUID to filter reviews"),
+  bundleId: z2.string().optional().describe("App bundle ID to filter reviews"),
+  platform: z2.enum(["ios", "android"]).optional().describe("Filter by platform"),
+  rating: z2.number().int().min(1).max(5).optional().describe("Filter by star rating (1-5)"),
+  replied: z2.boolean().optional().describe("Filter by replied status (true = has reply, false = no reply)"),
+  startDate: z2.string().optional().describe("Filter reviews from this date (ISO format: YYYY-MM-DD)"),
+  endDate: z2.string().optional().describe("Filter reviews until this date (ISO format: YYYY-MM-DD)"),
+  limit: z2.number().int().min(1).max(200).default(50).describe("Maximum number of reviews to return"),
+  sortBy: z2.enum(["date", "rating"]).default("date").describe("Sort reviews by date or rating")
+});
+var generateReviewReplySchema = z2.object({
+  reviewId: z2.string().describe("The review UUID to generate a reply for"),
+  assetId: z2.string().uuid().describe("The app UUID the review belongs to")
+});
+var sendReviewReplySchema = z2.object({
+  reviewId: z2.string().describe("The review UUID to reply to"),
+  assetId: z2.string().uuid().describe("The app UUID the review belongs to"),
+  response: z2.string().describe("The reply text to send")
+});
+var translateReviewSchema = z2.object({
+  reviewId: z2.string().describe("The review UUID to translate"),
+  assetId: z2.string().uuid().describe("The app UUID the review belongs to")
+});
+async function getReviews(input, client) {
+  try {
+    let assetId = input.assetId;
+    if (!assetId && input.bundleId) {
+      const allApps = await client.get("/api/assets", { limit: 100, offset: 0 });
+      const match = (allApps.data || []).find((a) => a.bundleId === input.bundleId);
+      if (!match) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No app found with bundle ID: ${input.bundleId}`
+            }
+          ],
+          isError: true
+        };
+      }
+      assetId = match.id;
+    }
+    const params = {
+      limit: input.limit,
+      sortBy: input.sortBy
+    };
+    if (assetId)
+      params.assetId = assetId;
+    if (input.platform)
+      params.platform = input.platform;
+    if (input.rating !== void 0)
+      params.rating = input.rating;
+    if (input.replied !== void 0)
+      params.responseStatus = input.replied ? "replied" : "unreplied";
+    if (input.startDate)
+      params.startDate = input.startDate;
+    if (input.endDate)
+      params.endDate = input.endDate;
+    const response = await client.get("/api/reviews", params);
+    const reviews = response.data || response.reviews || [];
+    const summary = {
+      totalReviews: reviews.length,
+      averageRating: reviews.length > 0 ? (reviews.reduce((sum, r) => sum + (r.rating || 0), 0) / reviews.length).toFixed(2) : 0,
+      repliedCount: reviews.filter((r) => r.developerResponse || r.hasReply).length,
+      unrepliedCount: reviews.filter((r) => !r.developerResponse && !r.hasReply).length
+    };
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson({
+            summary,
+            reviews: reviews.map((r) => ({
+              id: r.id,
+              appId: r.appId,
+              platform: r.platform,
+              rating: r.rating,
+              title: r.title,
+              body: r.body,
+              author: r.nickname || r.author,
+              date: r.lastModified || r.date,
+              version: r.appVersionString || r.version,
+              storeFront: r.storeFront,
+              hasReply: !!(r.developerResponse || r.hasReply),
+              reply: r.developerResponse ? typeof r.developerResponse === "object" ? r.developerResponse.response : r.developerResponse : r.reply || null
+            }))
+          })
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function generateReviewReply(input, client) {
+  try {
+    const response = await client.post(`/api/reviews/${input.reviewId}/generate-reply`, {
+      assetId: input.assetId
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function sendReviewReply(input, client) {
+  try {
+    const response = await client.post(`/api/reviews/${input.reviewId}/respond`, {
+      assetId: input.assetId,
+      response: input.response
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function translateReview(input, client) {
+  try {
+    const response = await client.post(`/api/reviews/${input.reviewId}/translate`, {
+      assetId: input.assetId
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/tools/analytics.ts
+import { z as z3 } from "zod";
+var discoverMetricsSchema = z3.object({
+  assetId: z3.string().uuid().describe("App UUID to check available metrics for")
+});
+var getMetricsSchema = z3.object({
+  assetId: z3.string().uuid().describe("App UUID"),
+  metrics: z3.array(z3.string()).min(1).describe('Metric names to query (e.g., ["proceeds", "totalDownloads"]). Use discover_metrics first to see available metrics.'),
+  startDate: z3.string().optional().describe("Start date (YYYY-MM-DD). Defaults to 30 days ago."),
+  endDate: z3.string().optional().describe("End date (YYYY-MM-DD). Defaults to today."),
+  granularity: z3.enum(["daily", "weekly", "monthly"]).default("daily").describe("Data granularity"),
+  dimension: z3.string().optional().describe('Optional dimension to break down by (e.g., "storefront" for country, "platform" for device). Use discover_dimensions to see options.'),
+  dimensionFilter: z3.string().optional().describe('Filter to a specific dimension value (e.g., "US" when dimension is "storefront")')
+});
+var discoverDimensionsSchema = z3.object({
+  assetId: z3.string().uuid().describe("App UUID"),
+  dimension: z3.string().optional().describe('If provided, returns the available values for this dimension (e.g., countries for "storefront")')
+});
+var METRIC_INFO = {
+  proceeds: { displayName: "Net Revenue (after store cut)", category: "Revenue", type: "currency" },
+  total_revenue: { displayName: "Gross Revenue", category: "Revenue", type: "currency" },
+  total_downloads: { displayName: "Total Downloads", category: "Downloads", type: "count" },
+  units: { displayName: "First-time Downloads", category: "Downloads", type: "count" },
+  redownloads: { displayName: "Re-downloads", category: "Downloads", type: "count" },
+  page_views: { displayName: "App Store Page Views", category: "Downloads", type: "count" },
+  impressions: { displayName: "App Store Impressions", category: "Downloads", type: "count" },
+  sessions: { displayName: "App Sessions", category: "Engagement", type: "count" },
+  active_devices: { displayName: "Active Devices", category: "Engagement", type: "count" },
+  crashes: { displayName: "Crashes", category: "Engagement", type: "count" },
+  paying_users: { displayName: "Paying Users", category: "Engagement", type: "count" },
+  active_subs: { displayName: "Active Subscriptions", category: "Subscriptions", type: "count" },
+  active_trials: { displayName: "Active Trials", category: "Subscriptions", type: "count" },
+  new_trials: { displayName: "New Trials", category: "Subscriptions", type: "count" },
+  trial_conversion_rate: { displayName: "Trial Conversion Rate", category: "Subscriptions", type: "percentage" },
+  subscription_retention_rate: { displayName: "Subscription Retention Rate", category: "Subscriptions", type: "percentage" },
+  products_sold: { displayName: "Products Sold (IAP)", category: "Revenue", type: "count" },
+  ad_spend: { displayName: "Ad Spend", category: "Ads", type: "currency" },
+  ad_impressions: { displayName: "Ad Impressions", category: "Ads", type: "count" },
+  ad_taps: { displayName: "Ad Taps/Clicks", category: "Ads", type: "count" },
+  ad_installs: { displayName: "Ad-attributed Installs", category: "Ads", type: "count" },
+  ad_conversions: { displayName: "Ad Conversions", category: "Ads", type: "count" }
+};
+var DIMENSION_INFO = {
+  storefront: "Country",
+  region: "Region",
+  platform: "Platform (device type)",
+  source: "Source",
+  appVersion: "App Version",
+  purchase: "Product",
+  appReferrer: "App Referrer",
+  domainReferrer: "Domain Referrer",
+  subscription_state: "Subscription Type",
+  duration: "Duration",
+  revenueShare: "Revenue Share",
+  campaign: "Campaign"
+};
+async function discoverMetrics(input, client) {
+  try {
+    const response = await client.get(`/api/assets/${input.assetId}/metrics/availability`);
+    const availableMetrics = response.data?.availableMetrics || [];
+    const metricGroups = response.data?.metricGroups || {};
+    const enriched = availableMetrics.map((metricName) => {
+      const info = METRIC_INFO[metricName];
+      return {
+        name: metricName,
+        displayName: info?.displayName || metricName,
+        category: info?.category || "Other",
+        type: info?.type || "count"
+      };
+    });
+    const byCategory = {};
+    for (const m of enriched) {
+      if (!byCategory[m.category])
+        byCategory[m.category] = [];
+      byCategory[m.category].push(m);
+    }
+    return {
+      content: [{
+        type: "text",
+        text: formatAsJson({
+          assetId: input.assetId,
+          totalAvailable: availableMetrics.length,
+          metricsByCategory: byCategory,
+          dataGroups: metricGroups,
+          tip: 'Use the metric "name" field in get_metrics. You can query multiple metrics at once.'
+        })
+      }]
+    };
+  } catch (error) {
+    return { content: [{ type: "text", text: formatError(error) }], isError: true };
+  }
+}
+async function getMetrics(input, client) {
+  try {
+    const endDate = input.endDate || (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const startDate = input.startDate || (() => {
+      const d = /* @__PURE__ */ new Date();
+      d.setDate(d.getDate() - 30);
+      return d.toISOString().split("T")[0];
+    })();
+    const params = {
+      metrics: input.metrics.join(","),
+      fromDate: startDate,
+      toDate: endDate,
+      granularity: input.granularity
+    };
+    if (input.dimension)
+      params.dimension = input.dimension;
+    if (input.dimensionFilter && input.dimension) {
+      params[`filter.${input.dimension}`] = input.dimensionFilter;
+    }
+    const response = await client.get(`/api/assets/${input.assetId}/metrics/timeseries`, params);
+    const data = response.data || {};
+    const changes = response.changes || {};
+    const meta = response.meta || {};
+    const summaries = {};
+    for (const [metricName, timeseries] of Object.entries(data)) {
+      const points = timeseries;
+      if (!Array.isArray(points) || points.length === 0) {
+        summaries[metricName] = { total: 0, average: 0, min: 0, max: 0, dataPoints: 0 };
+        continue;
+      }
+      const values = points.map((p) => p.value);
+      const total = values.reduce((s, v) => s + v, 0);
+      summaries[metricName] = {
+        total: Math.round(total * 100) / 100,
+        average: Math.round(total / values.length * 100) / 100,
+        min: Math.min(...values),
+        max: Math.max(...values),
+        dataPoints: values.length
+      };
+    }
+    const info = METRIC_INFO;
+    return {
+      content: [{
+        type: "text",
+        text: formatAsJson({
+          assetId: input.assetId,
+          dateRange: { start: startDate, end: endDate },
+          granularity: input.granularity,
+          dimension: input.dimension || null,
+          metrics: Object.keys(data).map((name) => ({
+            name,
+            displayName: info[name]?.displayName || name,
+            type: info[name]?.type || "count",
+            summary: summaries[name],
+            change: changes[name] || null
+          })),
+          timeseries: data,
+          meta
+        })
+      }]
+    };
+  } catch (error) {
+    return { content: [{ type: "text", text: formatError(error) }], isError: true };
+  }
+}
+async function discoverDimensions(input, client) {
+  try {
+    if (input.dimension) {
+      const response2 = await client.get(
+        `/api/assets/${input.assetId}/metrics/dimensions/${input.dimension}/values`
+      );
+      return {
+        content: [{
+          type: "text",
+          text: formatAsJson({
+            assetId: input.assetId,
+            dimension: input.dimension,
+            displayName: DIMENSION_INFO[input.dimension] || input.dimension,
+            values: response2.data || response2
+          })
+        }]
+      };
+    }
+    const response = await client.get(`/api/assets/${input.assetId}/metrics/dimensions`);
+    const dimensions = response.data || response || [];
+    const enriched = (Array.isArray(dimensions) ? dimensions : Object.keys(dimensions)).map((dim) => ({
+      name: dim,
+      displayName: DIMENSION_INFO[dim] || dim
+    }));
+    return {
+      content: [{
+        type: "text",
+        text: formatAsJson({
+          assetId: input.assetId,
+          dimensions: enriched,
+          tip: 'Use dimension name in get_metrics "dimension" param. Use discover_dimensions with a specific dimension to see available values.'
+        })
+      }]
+    };
+  } catch (error) {
+    return { content: [{ type: "text", text: formatError(error) }], isError: true };
+  }
+}
+
+// src/tools/agents.ts
+import { z as z4 } from "zod";
+var AGENT_TYPES = [
+  "review",
+  "monitoring",
+  "forecasting",
+  "growth",
+  "aso",
+  "ads",
+  "product",
+  "submission_review"
+];
+var AGENT_DESCRIPTIONS = {
+  review: "AI-powered review management \u2014 drafts and sends replies to app store reviews",
+  monitoring: "Anomaly detection \u2014 monitors metrics for unusual changes in downloads, revenue, etc.",
+  forecasting: "Revenue and metric forecasting \u2014 generates forward-looking projections",
+  growth: "Growth audit \u2014 analyzes app performance and provides growth scoring",
+  aso: "App Store Optimization \u2014 listing optimization suggestions for better visibility",
+  ads: "Ad campaign analysis \u2014 performance tracking and optimization recommendations",
+  product: "Product agent \u2014 automated app installation testing via BrowserStack",
+  submission_review: "Submission review \u2014 GitHub-based review workflow for app submissions"
+};
+var listAgentsSchema = z4.object({});
+var getAgentDetailsSchema = z4.object({
+  agentType: z4.enum(AGENT_TYPES).describe("The type of agent to get details for"),
+  assetId: z4.string().uuid().optional().describe("App UUID to get agent config for (when agent is per-asset)")
+});
+var getAgentRunHistorySchema = z4.object({
+  agentType: z4.enum(AGENT_TYPES).describe("The type of agent to get run history for"),
+  assetId: z4.string().uuid().optional().describe("App UUID to filter runs"),
+  limit: z4.number().int().min(1).max(100).default(20).describe("Maximum number of runs to return")
+});
+var triggerAgentRunSchema = z4.object({
+  agentId: z4.string().describe("The agent ID to trigger a run for"),
+  assetId: z4.string().uuid().optional().describe("Optional app UUID to run the agent against")
+});
+var pauseAgentSchema = z4.object({
+  agentId: z4.string().describe("The agent ID to pause")
+});
+var resumeAgentSchema = z4.object({
+  agentId: z4.string().describe("The agent ID to resume")
+});
+var getAgentActivitySchema = z4.object({
+  agentId: z4.string().describe("The agent ID to get activity for")
+});
+async function listAgents(_input, client) {
+  try {
+    let apiAgents = null;
+    try {
+      const response = await client.get("/api/agents");
+      apiAgents = response.data || response.agents || response;
+    } catch {
+    }
+    if (apiAgents && Array.isArray(apiAgents)) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatAsJson({
+              totalAgents: apiAgents.length,
+              agents: apiAgents
+            })
+          }
+        ]
+      };
+    }
+    const agents = AGENT_TYPES.map((type) => ({
+      type,
+      description: AGENT_DESCRIPTIONS[type],
+      available: true
+    }));
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson({
+            totalAgents: agents.length,
+            agents
+          })
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function getAgentDetails(input, client) {
+  try {
+    try {
+      const params = {};
+      if (input.assetId)
+        params.assetId = input.assetId;
+      const response2 = await client.get(`/api/agents/${input.agentType}`, params);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatAsJson(response2.data || response2)
+          }
+        ]
+      };
+    } catch {
+    }
+    const response = {
+      type: input.agentType,
+      description: AGENT_DESCRIPTIONS[input.agentType],
+      message: "Detailed agent configuration is available through the platform dashboard."
+    };
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function getAgentRunHistory(input, client) {
+  try {
+    try {
+      const params = {
+        limit: input.limit
+      };
+      if (input.assetId)
+        params.assetId = input.assetId;
+      const response = await client.get(`/api/agents/${input.agentType}/runs`, params);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formatAsJson({
+              agentType: input.agentType,
+              ...response.data || response
+            })
+          }
+        ]
+      };
+    } catch {
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson({
+            agentType: input.agentType,
+            message: `Run history for ${input.agentType} agent is available through the platform dashboard. This agent type does not have a dedicated run log table yet.`
+          })
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function triggerAgentRun(input, client) {
+  try {
+    const body = {};
+    if (input.assetId)
+      body.assetId = input.assetId;
+    const response = await client.post(`/api/agents/${input.agentId}/run`, body);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response.data || response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function pauseAgent(input, client) {
+  try {
+    const response = await client.post(`/api/agents/${input.agentId}/pause`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response.data || response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function resumeAgent(input, client) {
+  try {
+    const response = await client.post(`/api/agents/${input.agentId}/resume`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response.data || response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function getAgentActivity(input, client) {
+  try {
+    const response = await client.get(`/api/agents/${input.agentId}/activity`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response.data || response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/tools/anomalies.ts
+import { z as z5 } from "zod";
+var getAnomaliesSchema = z5.object({
+  assetId: z5.string().uuid().optional().describe("Filter anomalies by app UUID"),
+  severity: z5.enum(["low", "medium", "high", "critical"]).optional().describe("Filter by severity level"),
+  type: z5.enum(["surge", "decline"]).optional().describe("Filter by anomaly type"),
+  status: z5.enum(["new", "viewed", "acknowledged", "dismissed"]).optional().describe("Filter by status"),
+  metricName: z5.string().optional().describe('Filter by metric name (e.g., "proceeds", "units")'),
+  fromDate: z5.string().optional().describe("Filter anomalies from this date (YYYY-MM-DD)"),
+  toDate: z5.string().optional().describe("Filter anomalies until this date (YYYY-MM-DD)"),
+  excludeDismissed: z5.boolean().default(true).describe("Exclude dismissed anomalies (default: true)"),
+  limit: z5.number().int().min(1).max(100).default(50).describe("Maximum number of anomalies to return")
+});
+var getAnomalyDetailSchema = z5.object({
+  id: z5.string().uuid().describe("The anomaly UUID to get details for")
+});
+var acknowledgeAnomalySchema = z5.object({
+  id: z5.string().uuid().describe("The anomaly UUID to acknowledge")
+});
+var dismissAnomalySchema = z5.object({
+  id: z5.string().uuid().describe("The anomaly UUID to dismiss")
+});
+async function getAnomalies(input, client) {
+  try {
+    const params = {
+      limit: input.limit
+    };
+    if (input.assetId)
+      params.assetId = input.assetId;
+    if (input.severity)
+      params.severity = input.severity;
+    if (input.type)
+      params.type = input.type;
+    if (input.status)
+      params.status = input.status;
+    if (input.metricName)
+      params.metricName = input.metricName;
+    if (input.fromDate)
+      params.fromDate = input.fromDate;
+    if (input.toDate)
+      params.toDate = input.toDate;
+    if (input.excludeDismissed)
+      params.excludeDismissed = input.excludeDismissed;
+    const response = await client.get("/api/anomalies", params);
+    const anomalies = response.data || response.anomalies || [];
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson({
+            total: anomalies.length,
+            anomalies: anomalies.map((a) => ({
+              id: a.id,
+              assetId: a.assetId,
+              assetName: a.assetName,
+              assetIcon: a.assetIcon,
+              anomalyDate: a.anomalyDate,
+              metricName: a.metricName,
+              sourceType: a.sourceType,
+              type: a.type,
+              severity: a.severity,
+              actualValue: parseFloat(a.actualValue || "0"),
+              expectedValue: parseFloat(a.expectedValue || "0"),
+              deviationPercent: parseFloat(a.deviationPercent || "0"),
+              confidence: parseFloat(a.confidence || "0"),
+              explanation: a.explanation,
+              suggestedActions: a.suggestedActions,
+              status: a.status,
+              detectedAt: a.detectedAt
+            }))
+          })
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function getAnomalyDetail(input, client) {
+  try {
+    const response = await client.get(`/api/anomalies/${input.id}`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function acknowledgeAnomaly(input, client) {
+  try {
+    const response = await client.patch(`/api/anomalies/${input.id}/acknowledge`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function dismissAnomaly(input, client) {
+  try {
+    const response = await client.patch(`/api/anomalies/${input.id}/dismiss`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/tools/ads.ts
+import { z as z6 } from "zod";
+var getAdsPerformanceSchema = z6.object({
+  assetId: z6.string().uuid().optional().describe("Filter by app UUID"),
+  platform: z6.enum(["apple_search_ads", "google_ads", "meta_ads", "tiktok_ads"]).optional().describe("Filter by ad platform"),
+  fromDate: z6.string().optional().describe("Start date for performance data (YYYY-MM-DD)"),
+  toDate: z6.string().optional().describe("End date for performance data (YYYY-MM-DD)"),
+  limit: z6.number().int().min(1).max(100).default(50).describe("Maximum number of campaigns to return")
+});
+async function getAdsPerformance(input, client) {
+  try {
+    const params = {
+      limit: input.limit
+    };
+    if (input.assetId)
+      params.assetId = input.assetId;
+    if (input.platform)
+      params.platform = input.platform;
+    if (input.fromDate)
+      params.fromDate = input.fromDate;
+    if (input.toDate)
+      params.toDate = input.toDate;
+    const response = await client.get("/api/ads/campaigns", params);
+    const campaigns = response.data || response.campaigns || [];
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson({
+            total: campaigns.length,
+            campaigns: campaigns.map((c) => ({
+              id: c.id,
+              assetId: c.assetId,
+              assetName: c.assetName,
+              platformCampaignId: c.platformCampaignId,
+              name: c.name,
+              status: c.status,
+              objective: c.objective,
+              platform: c.platform,
+              linkSource: c.linkSource,
+              linkedAt: c.linkedAt,
+              recentPerformance: c.recentPerformance || null
+            }))
+          })
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/tools/growth.ts
+import { z as z7 } from "zod";
+var getGrowthAuditSchema = z7.object({
+  assetId: z7.string().uuid().describe("App UUID to audit")
+});
+var getGrowthScoreSchema = z7.object({
+  assetId: z7.string().uuid().describe("App UUID to score")
+});
+async function getGrowthAudit(input, client) {
+  try {
+    const response = await client.get(`/api/growth/audit/${input.assetId}`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response.data || response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function getGrowthScore(input, client) {
+  try {
+    const response = await client.get(`/api/growth/score/${input.assetId}`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response.data || response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/tools/forecasting.ts
+import { z as z8 } from "zod";
+var getForecastsSchema = z8.object({
+  assetId: z8.string().uuid().describe("App UUID to get forecasts for"),
+  dataPoints: z8.number().int().min(4).max(52).default(12).describe("Number of historical data points to include")
+});
+async function getForecasts(input, client) {
+  try {
+    const response = await client.get("/api/forecasting/forecast", {
+      assetId: input.assetId,
+      dataPoints: input.dataPoints
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response.data || response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/tools/dashboard.ts
+import { z as z9 } from "zod";
+var getDashboardOverviewSchema = z9.object({});
+async function getDashboardOverview(_input, client) {
+  try {
+    const [overviewResponse, sidebarResponse] = await Promise.all([
+      client.get("/api/dashboard/overview-metrics").catch(() => null),
+      client.get("/api/dashboard/sidebar-assets").catch(() => null)
+    ]);
+    const overview = overviewResponse?.data || overviewResponse || {};
+    const sidebarAssets = sidebarResponse?.data || sidebarResponse || [];
+    const apps = Array.isArray(sidebarAssets) ? sidebarAssets : [];
+    const totalValuation = apps.reduce((sum, a) => {
+      return sum + parseFloat(a.currentValuation || "0");
+    }, 0);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson({
+            portfolio: {
+              totalApps: apps.length,
+              totalValuation: totalValuation > 0 ? totalValuation : null,
+              apps: apps.map((a) => ({
+                id: a.id,
+                name: a.name,
+                bundleId: a.bundleId,
+                platform: a.appleAppId ? "ios" : a.googleAppId ? "android" : "unknown",
+                currentValuation: a.currentValuation ? parseFloat(a.currentValuation) : null,
+                rating: a.rating ? parseFloat(a.rating) : null,
+                ratingCount: a.ratingCount || null,
+                category: a.category || null,
+                iconUrl: a.iconUrl || null
+              }))
+            },
+            overview
+          })
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/tools/actions.ts
+import { z as z10 } from "zod";
+var listPendingActionsSchema = z10.object({
+  assetId: z10.string().uuid().optional().describe("Filter by app UUID"),
+  limit: z10.number().int().min(1).max(100).default(50).describe("Maximum number of actions to return")
+});
+var approveActionSchema = z10.object({
+  actionId: z10.string().describe("The draft reply ID to approve"),
+  editedReply: z10.string().optional().describe("Optionally modify the reply text before approving")
+});
+var rejectActionSchema = z10.object({
+  actionId: z10.string().describe("The draft reply ID to reject/delete")
+});
+async function listPendingActions(input, client) {
+  try {
+    const params = {
+      limit: input.limit
+    };
+    if (input.assetId)
+      params.assetId = input.assetId;
+    const response = await client.get("/api/pending-actions", params);
+    const actions = response.data || response.actions || [];
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson({
+            total: actions.length,
+            actions
+          })
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function approveAction(input, client) {
+  try {
+    const body = {};
+    if (input.editedReply)
+      body.editedReply = input.editedReply;
+    const response = await client.post(`/api/pending-actions/${input.actionId}/approve`, body);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson({
+            success: true,
+            actionId: input.actionId,
+            status: "approved",
+            message: "Reply has been approved and queued for sending",
+            ...response.data || {}
+          })
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function rejectAction(input, client) {
+  try {
+    const response = await client.post(`/api/pending-actions/${input.actionId}/reject`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson({
+            success: true,
+            actionId: input.actionId,
+            status: "rejected",
+            message: "Draft reply has been rejected and removed",
+            ...response.data || {}
+          })
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/tools/aso.ts
+import { z as z11 } from "zod";
+var getAsoSummarySchema = z11.object({
+  assetId: z11.string().uuid().describe("App UUID to get ASO summary for")
+});
+var getAsoRecommendationsSchema = z11.object({
+  assetId: z11.string().uuid().describe("App UUID to get ASO recommendations for")
+});
+var getAsoKeywordsSchema = z11.object({
+  assetId: z11.string().uuid().describe("App UUID to get keyword intelligence for"),
+  locale: z11.string().optional().describe('Locale code to filter keywords (e.g., "en-US", "de-DE"). Returns all locales if omitted.')
+});
+var getAsoExperimentsSchema = z11.object({
+  assetId: z11.string().uuid().describe("App UUID to list ASO experiments for"),
+  status: z11.enum(["proposed", "approved", "applied", "measuring", "completed", "reverted"]).optional().describe("Filter experiments by status"),
+  limit: z11.number().int().min(1).max(100).default(20).describe("Maximum number of experiments to return"),
+  offset: z11.number().int().min(0).default(0).describe("Number of experiments to skip for pagination")
+});
+var getAsoLocaleSnapshotsSchema = z11.object({
+  assetId: z11.string().uuid().describe("App UUID to get locale snapshots for")
+});
+var triggerAsoAnalysisSchema = z11.object({
+  assetId: z11.string().uuid().describe("App UUID to trigger ASO analysis for")
+});
+async function getAsoSummary(input, client) {
+  try {
+    const response = await client.get(`/api/assets/${input.assetId}/aso/summary`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function getAsoRecommendations(input, client) {
+  try {
+    const response = await client.get(`/api/assets/${input.assetId}/aso/recommendations`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function getAsoKeywords(input, client) {
+  try {
+    const params = {};
+    if (input.locale)
+      params.locale = input.locale;
+    const response = await client.get(`/api/assets/${input.assetId}/aso/keyword-intelligence`, params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function getAsoExperiments(input, client) {
+  try {
+    const params = {
+      limit: input.limit,
+      offset: input.offset
+    };
+    if (input.status)
+      params.status = input.status;
+    const response = await client.get(`/api/assets/${input.assetId}/aso/experiments`, params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function getAsoLocaleSnapshots(input, client) {
+  try {
+    const response = await client.get(`/api/assets/${input.assetId}/aso/locale-snapshots`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function triggerAsoAnalysis(input, client) {
+  try {
+    const response = await client.post(`/api/assets/${input.assetId}/aso/analyze`);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/tools/chat.ts
+import { z as z12 } from "zod";
+var listConversationsSchema = z12.object({
+  limit: z12.number().int().min(1).max(100).default(20).describe("Maximum number of conversations to return")
+});
+var getConversationMessagesSchema = z12.object({
+  conversationId: z12.string().uuid().describe("The conversation UUID to get messages for")
+});
+var sendChatMessageSchema = z12.object({
+  message: z12.string().describe("The message to send to the AI chat"),
+  conversationId: z12.string().uuid().optional().describe("Existing conversation UUID to continue. Starts a new conversation if omitted."),
+  agentType: z12.string().optional().describe("Agent type to use for the conversation (e.g., review, monitoring, forecasting)")
+});
+async function listConversations(input, client) {
+  try {
+    const response = await client.get("/api/chat/conversations", {
+      limit: input.limit
+    });
+    const conversations = response.data || response.conversations || response;
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson({
+            totalConversations: Array.isArray(conversations) ? conversations.length : 0,
+            conversations
+          })
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function getConversationMessages(input, client) {
+  try {
+    const response = await client.get(`/api/chat/messages/${input.conversationId}`);
+    const messages = response.data || response.messages || response;
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson({
+            conversationId: input.conversationId,
+            totalMessages: Array.isArray(messages) ? messages.length : 0,
+            messages
+          })
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function sendChatMessage(input, client) {
+  try {
+    const body = {
+      message: input.message
+    };
+    if (input.conversationId)
+      body.conversationId = input.conversationId;
+    if (input.agentType)
+      body.agentType = input.agentType;
+    const response = await client.post("/api/chat", body);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response.data || response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/tools/index.ts
+function registerTools(server, client, options = {}) {
+  const rateLimiter = options.rateLimiter ?? new RateLimiter(100, 6e4);
+  function wrapTool(_toolName, handler) {
+    return async (input) => {
+      const rateCheck = rateLimiter.check("default");
+      if (!rateCheck.allowed) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Rate limit exceeded. Try again in ${Math.ceil(
+                rateCheck.retryAfterMs / 1e3
+              )}s. Limit: 100 requests/minute.`
+            }
+          ],
+          isError: true
+        };
+      }
+      return handler(input, client);
+    };
+  }
+  function tool(name, title, description, schema, handler, annotations) {
+    server.registerTool(
+      name,
+      {
+        title,
+        description,
+        inputSchema: schema.shape,
+        annotations: { title, ...annotations }
+      },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      wrapTool(name, handler)
+    );
+  }
+  tool(
+    "list_apps",
+    "List apps",
+    "List all mobile apps in your Fload organization. Returns app metadata including name, bundle ID, platform (iOS/Android), icon URL, and category.",
+    listAppsSchema,
+    listApps,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_app_details",
+    "Get app details",
+    "Get detailed information about a specific app, including metadata, connected data sources (App Store Connect, Google Play Console), and sync status. Provide either assetId (UUID) or bundleId.",
+    getAppDetailsSchema,
+    getAppDetails,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_reviews",
+    "Get reviews",
+    "Get app reviews with flexible filtering. Filter by app (assetId or bundleId), platform, rating (1-5 stars), replied status, and date range. Returns reviews with metadata, author, body text, and reply status. Useful for sentiment analysis, support workflows, and review management.",
+    getReviewsSchema,
+    getReviews,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "generate_review_reply",
+    "Generate review reply (AI draft)",
+    "Generate an AI draft reply for an app review. The AI uses the review context and any configured agent settings (tone, custom instructions) to craft a response. Returns the generated draft text. Does not publish \u2014 call send_review_reply or approve_action to publish the draft.",
+    generateReviewReplySchema,
+    generateReviewReply,
+    { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+  );
+  tool(
+    "send_review_reply",
+    "Send review reply",
+    "Send a reply to an app review on the App Store or Google Play. The response text will be submitted as the developer response. This is a write operation that publishes the reply publicly \u2014 treat as destructive (cannot be silently undone).",
+    sendReviewReplySchema,
+    sendReviewReply,
+    { readOnlyHint: false, destructiveHint: true, openWorldHint: true }
+  );
+  tool(
+    "translate_review",
+    "Translate review",
+    "Translate a review to English. Useful for reviews written in other languages. Returns the translated text. Does not modify the review in Fload.",
+    translateReviewSchema,
+    translateReview,
+    { readOnlyHint: true, openWorldHint: true }
+  );
+  tool(
+    "discover_metrics",
+    "Discover available metrics",
+    "Discover what metrics are available for an app. Returns all available metrics organized by category (revenue, downloads, subscriptions, engagement, ads). Always call this first before querying metrics to know what data exists.",
+    discoverMetricsSchema,
+    discoverMetrics,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_metrics",
+    "Get metrics",
+    "Query metric timeseries data for an app. Supports 30+ metrics (proceeds, totalDownloads, activeSubs, sessions, crashes, adSpend, etc.). Can query multiple metrics at once. Supports dimensional breakdowns (by country, platform, campaign). Use discover_metrics first to see available metrics.",
+    getMetricsSchema,
+    getMetrics,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "discover_dimensions",
+    "Discover available dimensions",
+    "Discover available dimensions for breaking down metrics (e.g., country, platform, app version, campaign). Optionally get the available values for a specific dimension.",
+    discoverDimensionsSchema,
+    discoverDimensions,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "list_agents",
+    "List agents",
+    "List all available AI agents in the Fload platform with their current status. Returns agent types (review, monitoring, forecasting, growth, aso, ads, product, submission_review) and configuration status.",
+    listAgentsSchema,
+    listAgents,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_agent_details",
+    "Get agent details",
+    "Get detailed configuration and status for a specific agent type. For the review agent, returns per-asset settings (mode, tone, custom instructions). For the product agent, returns latest run details.",
+    getAgentDetailsSchema,
+    getAgentDetails,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_agent_run_history",
+    "Get agent run history",
+    "Get run history for a specific agent type. Currently available for the product agent (BrowserStack app installation runs). Returns run status, timing, and error details.",
+    getAgentRunHistorySchema,
+    getAgentRunHistory,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "trigger_agent_run",
+    "Trigger agent run",
+    "Trigger a manual run for an agent. Optionally specify an asset (app) to run the agent against. Returns the triggered run details. Reversible in the sense that agent runs can be paused or dismissed.",
+    triggerAgentRunSchema,
+    triggerAgentRun,
+    { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+  );
+  tool(
+    "pause_agent",
+    "Pause agent",
+    "Pause a running agent. The agent will stop processing until resumed. Reversible via resume_agent.",
+    pauseAgentSchema,
+    pauseAgent,
+    { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+  );
+  tool(
+    "resume_agent",
+    "Resume agent",
+    "Resume a paused agent. The agent will continue processing from where it left off. Reversible via pause_agent.",
+    resumeAgentSchema,
+    resumeAgent,
+    { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_agent_activity",
+    "Get agent activity",
+    "Get the recent activity log for an agent. Returns a chronological list of actions the agent has taken, including timestamps, event types, and details.",
+    getAgentActivitySchema,
+    getAgentActivity,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_anomalies",
+    "Get anomalies",
+    "Get detected anomalies (unusual metric changes) for your apps. Filter by app, severity (low/medium/high/critical), type (surge/decline), status, metric name, and date range. Returns actual vs expected values, deviation percentage, confidence, and suggested actions.",
+    getAnomaliesSchema,
+    getAnomalies,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_anomaly_detail",
+    "Get anomaly detail",
+    "Get full detail for a single anomaly including chart data. Returns the anomaly metadata, actual vs expected values, and historical metric data points for visualization.",
+    getAnomalyDetailSchema,
+    getAnomalyDetail,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "acknowledge_anomaly",
+    "Acknowledge anomaly",
+    'Mark an anomaly as acknowledged. This updates the anomaly status from "new" to "acknowledged", indicating it has been reviewed but not dismissed. Reversible \u2014 anomaly can be reset or dismissed later.',
+    acknowledgeAnomalySchema,
+    acknowledgeAnomaly,
+    { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+  );
+  tool(
+    "dismiss_anomaly",
+    "Dismiss anomaly",
+    'Dismiss an anomaly. This updates the anomaly status to "dismissed", removing it from active alerts. Dismissed anomalies are excluded from queries by default. Soft state change \u2014 the anomaly row is preserved and can be un-dismissed later.',
+    dismissAnomalySchema,
+    dismissAnomaly,
+    { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_ads_performance",
+    "Get ads performance",
+    "Get ad campaign performance data across platforms (Apple Search Ads, Google Ads, Meta Ads, TikTok Ads). Returns campaign metadata, status, and for Apple Search Ads includes daily performance snapshots (spend, impressions, taps, installs, CPI, TTR, conversion rate).",
+    getAdsPerformanceSchema,
+    getAdsPerformance,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_growth_audit",
+    "Get growth audit",
+    "Get a comprehensive growth audit for an app. Synthesizes data from review sentiment analysis, recent anomalies, valuation trends, and connector health into an actionable growth assessment.",
+    getGrowthAuditSchema,
+    getGrowthAudit,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_growth_score",
+    "Get growth score",
+    "Get a calculated growth score (0-100) and grade (A-F) for an app. The score is based on app store rating, valuation trend, recent anomalies, review sentiment, and data connector health. Includes a breakdown of scoring factors.",
+    getGrowthScoreSchema,
+    getGrowthScore,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_forecasts",
+    "Get forecasts",
+    "Get valuation-based forecasts and trend analysis for an app. Returns historical valuation data points, trend statistics (direction, volatility), and simple linear projections. For detailed metric forecasting with statistical models, use the platform dashboard.",
+    getForecastsSchema,
+    getForecasts,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_dashboard_overview",
+    "Get dashboard overview",
+    "Get an aggregated dashboard overview for the organization. Returns portfolio summary (apps, valuations, ratings), data connector health status, and alerts (recent anomalies, pending review drafts).",
+    getDashboardOverviewSchema,
+    getDashboardOverview,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "list_pending_actions",
+    "List pending actions",
+    "List pending actions awaiting approval. Currently shows AI-generated review draft replies that have not been sent yet. Includes the original review context and the drafted reply. Filter by app.",
+    listPendingActionsSchema,
+    listPendingActions,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "approve_action",
+    "Approve pending action",
+    "Approve a pending action (e.g., a review draft reply). Approving a review reply publishes it to the store \u2014 treat as destructive (publicly visible, cannot be silently undone). Optionally edit the reply text before approving.",
+    approveActionSchema,
+    approveAction,
+    { readOnlyHint: false, destructiveHint: true, openWorldHint: true }
+  );
+  tool(
+    "reject_action",
+    "Reject pending action",
+    "Reject a pending action (e.g., delete a review draft reply). The draft will be permanently removed. Destructive \u2014 not recoverable without regenerating the draft.",
+    rejectActionSchema,
+    rejectAction,
+    { readOnlyHint: false, destructiveHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_aso_summary",
+    "Get ASO summary",
+    "Get the ASO (App Store Optimization) score, health status, and overview for an app. Returns an overall optimization score and key ASO health indicators. Use this for a quick snapshot of how well an app is optimized for store search and discovery.",
+    getAsoSummarySchema,
+    getAsoSummary,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_aso_recommendations",
+    "Get ASO recommendations",
+    "Get actionable ASO recommendations for an app, including suggested improvements to the title, subtitle, keywords, and description. Each recommendation explains the rationale and expected impact on search visibility.",
+    getAsoRecommendationsSchema,
+    getAsoRecommendations,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_aso_keywords",
+    "Get ASO keywords",
+    'Get keyword intelligence for an app \u2014 current keyword rankings, search volume estimates, difficulty scores, and competitor keyword data. Optionally filter by locale (e.g., "en-US"). Useful for identifying keyword opportunities and tracking ranking changes.',
+    getAsoKeywordsSchema,
+    getAsoKeywords,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_aso_experiments",
+    "Get ASO experiments",
+    "List ASO experiments (A/B tests and metadata changes) for an app. Filter by status: proposed, approved, applied, measuring, completed, or reverted. Returns experiment details, variants, and results when available. Supports pagination.",
+    getAsoExperimentsSchema,
+    getAsoExperiments,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_aso_locale_snapshots",
+    "Get ASO locale snapshots",
+    "Get current App Store and Google Play listing snapshots across all locales for an app. Returns the live title, subtitle, keywords, description, and promotional text for each locale. Useful for auditing localized metadata consistency.",
+    getAsoLocaleSnapshotsSchema,
+    getAsoLocaleSnapshots,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "trigger_aso_analysis",
+    "Trigger ASO analysis",
+    "Trigger a new ASO analysis run for an app. This kicks off a fresh evaluation of the app's store listing metadata, keyword rankings, and competitive positioning. Results will be reflected in subsequent calls to get_aso_summary and get_aso_recommendations.",
+    triggerAsoAnalysisSchema,
+    triggerAsoAnalysis,
+    { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+  );
+  tool(
+    "list_conversations",
+    "List conversations",
+    "List chat conversations in the Fload AI chat. Returns conversation metadata including title, creation date, and last message preview. Use limit to control how many are returned.",
+    listConversationsSchema,
+    listConversations,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "get_conversation_messages",
+    "Get conversation messages",
+    "Get all messages in a specific chat conversation. Returns the full message history including user messages and AI responses with timestamps and roles.",
+    getConversationMessagesSchema,
+    getConversationMessages,
+    { readOnlyHint: true, openWorldHint: false }
+  );
+  tool(
+    "send_chat_message",
+    "Send chat message",
+    "Send a message to the Fload AI chat assistant. Starts a new conversation if no conversationId is provided, or continues an existing one. Optionally specify an agentType to route to a specialized agent (review, monitoring, forecasting, etc.). Adds a message to your chat history \u2014 not publicly visible.",
+    sendChatMessageSchema,
+    sendChatMessage,
+    { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+  );
+}
+export {
+  acknowledgeAnomaly,
+  acknowledgeAnomalySchema,
+  approveAction,
+  approveActionSchema,
+  discoverDimensions,
+  discoverDimensionsSchema,
+  discoverMetrics,
+  discoverMetricsSchema,
+  dismissAnomaly,
+  dismissAnomalySchema,
+  generateReviewReply,
+  generateReviewReplySchema,
+  getAdsPerformance,
+  getAdsPerformanceSchema,
+  getAgentActivity,
+  getAgentActivitySchema,
+  getAgentDetails,
+  getAgentDetailsSchema,
+  getAgentRunHistory,
+  getAgentRunHistorySchema,
+  getAnomalies,
+  getAnomaliesSchema,
+  getAnomalyDetail,
+  getAnomalyDetailSchema,
+  getAppDetails,
+  getAppDetailsSchema,
+  getAsoExperiments,
+  getAsoExperimentsSchema,
+  getAsoKeywords,
+  getAsoKeywordsSchema,
+  getAsoLocaleSnapshots,
+  getAsoLocaleSnapshotsSchema,
+  getAsoRecommendations,
+  getAsoRecommendationsSchema,
+  getAsoSummary,
+  getAsoSummarySchema,
+  getConversationMessages,
+  getConversationMessagesSchema,
+  getDashboardOverview,
+  getDashboardOverviewSchema,
+  getForecasts,
+  getForecastsSchema,
+  getGrowthAudit,
+  getGrowthAuditSchema,
+  getGrowthScore,
+  getGrowthScoreSchema,
+  getMetrics,
+  getMetricsSchema,
+  getReviews,
+  getReviewsSchema,
+  listAgents,
+  listAgentsSchema,
+  listApps,
+  listAppsSchema,
+  listConversations,
+  listConversationsSchema,
+  listPendingActions,
+  listPendingActionsSchema,
+  pauseAgent,
+  pauseAgentSchema,
+  registerTools,
+  rejectAction,
+  rejectActionSchema,
+  resumeAgent,
+  resumeAgentSchema,
+  sendChatMessage,
+  sendChatMessageSchema,
+  sendReviewReply,
+  sendReviewReplySchema,
+  translateReview,
+  translateReviewSchema,
+  triggerAgentRun,
+  triggerAgentRunSchema,
+  triggerAsoAnalysis,
+  triggerAsoAnalysisSchema
+};
+//# sourceMappingURL=index.js.map