@fload-ai/mcp 0.1.1 → 0.2.2

package/dist/index.js

@@ -1,37 +1,105 @@
-#!/usr/bin/env node
-
-// src/index.ts
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+// src/public-errors.ts
+var INTERNAL_ERROR_PATTERNS = [
+  /\b(stack|trace|at\s+[\w.$<>]+\s*\()/i,
+  /\b(sql|postgres|drizzle|database|constraint|duplicate key|violates|relation)\b/i,
+  /\b(fetch|undici|socket|ECONNRESET|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|HTTP\s+\d{3})\b/i,
+  /\b(token|secret|api[_-]?key|authorization|bearer|cookie|password)\b/i,
+  /\b[a-z0-9]+_(secret|token|key)\b/i,
+  /\b(secret|token|key)[_-][a-z0-9]+\b/i,
+  /\b(scrap|browser|patchright|playwright|chromium|page\.|locator|selector)\b/i,
+  /\b(redis|bullmq|queue|job id|worker)\b/i
+];
+function looksInternal(message) {
+  return INTERNAL_ERROR_PATTERNS.some((pattern) => pattern.test(message));
+}
+function publicMcpErrorMessage(message, fallbackMessage = "Fload could not complete the request. Please try again.") {
+  const raw = message instanceof Error ? message.message : typeof message === "string" ? message : "";
+  const normalized = raw.replace(/\s+/g, " ").trim();
+  if (!normalized || normalized.length > 180 || looksInternal(normalized)) {
+    return fallbackMessage;
+  }
+  return normalized;
+}
 
-// src/config.ts
-import "dotenv/config";
-import { readFileSync, existsSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-function loadConfig() {
-  const apiKey = process.env.FLOAD_API_KEY;
-  const apiUrl = process.env.FLOAD_API_URL || "https://api.fload.com";
-  if (apiKey) {
-    return { apiKey, apiUrl };
+// src/api-client.ts
+var FloadApiClient = class {
+  constructor(baseUrl, apiKey) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
   }
-  const configPath = join(homedir(), ".fload", "config.json");
-  if (existsSync(configPath)) {
-    try {
-      const configData = JSON.parse(readFileSync(configPath, "utf-8"));
-      if (configData.apiKey) {
-        return {
-          apiKey: configData.apiKey,
-          apiUrl: configData.apiUrl || apiUrl
-        };
+  async request(path, options = {}) {
+    const url = `${this.baseUrl}${path}`;
+    const headers = {
+      Authorization: `Bearer ${this.apiKey}`,
+      ...options.body ? { "Content-Type": "application/json" } : {},
+      ...options.headers
+    };
+    const response = await fetch(url, {
+      ...options,
+      headers
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: response.statusText }));
+      const safeError = publicMcpErrorMessage(
+        error.publicMessage || error.message || response.statusText,
+        response.status >= 500 ? "Fload could not complete the request. Please try again." : "Fload rejected the request. Please check access and try again."
+      );
+      throw new Error(safeError);
+    }
+    return response.json();
+  }
+  async get(path, params) {
+    const searchParams = new URLSearchParams();
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0)
+          searchParams.set(key, String(value));
       }
-    } catch (error) {
-      console.error("Failed to parse config file:", error);
     }
+    const query = searchParams.toString();
+    return this.request(`${path}${query ? `?${query}` : ""}`);
   }
-  throw new Error(
-    'Fload MCP requires an API key. Set FLOAD_API_KEY environment variable or create ~/.fload/config.json with {"apiKey": "fload_sk_..."}'
-  );
-}
+  async post(path, body) {
+    return this.request(path, {
+      method: "POST",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  async patch(path, body) {
+    return this.request(path, {
+      method: "PATCH",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  async delete(path) {
+    return this.request(path, { method: "DELETE" });
+  }
+  /**
+   * POST to a streaming endpoint (SSE / AI SDK UI-message stream) and
+   * return the raw response body as text. Callers parse the event lines.
+   */
+  async postStream(path, body) {
+    const url = `${this.baseUrl}${path}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+        Accept: "text/event-stream"
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ message: response.statusText }));
+      const safeError = publicMcpErrorMessage(
+        error.publicMessage || error.message || response.statusText,
+        response.status >= 500 ? "Fload could not complete the request. Please try again." : "Fload rejected the request. Please check access and try again."
+      );
+      throw new Error(safeError);
+    }
+    return response.text();
+  }
+};
 
 // src/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -91,9 +159,12 @@ async function listApps(input, client) {
   try {
     const response = await client.get("/api/assets", {
       limit: input.limit,
-      offset: 0
+      offset: 0,
+      // The listing hides assets without a valuation by default; "list all
+      // apps" must include apps that haven't been valued yet (FLO-734).
+      includeUnvalued: "true"
     });
-    const apps = response.data || [];
+    const apps = response.data ?? [];
     const filtered = input.platform ? apps.filter((app) => {
       if (input.platform === "ios")
         return !!app.appleAppId;
@@ -137,8 +208,14 @@ async function getAppDetails(input, client) {
     }
     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);
+      const allApps = await client.get("/api/assets", {
+        limit: 100,
+        offset: 0,
+        includeUnvalued: "true"
+      });
+      const match = (allApps.data ?? []).find(
+        (app2) => app2.bundleId === input.bundleId
+      );
       if (!match) {
         return {
           content: [
@@ -152,8 +229,13 @@ async function getAppDetails(input, client) {
       }
       assetId = match.id;
     }
-    const response = await client.get(`/api/assets/${assetId}`);
-    const app = response.data || response;
+    const response = await client.get(
+      `/api/assets/${assetId}`
+    );
+    const app = response.data;
+    if (!app) {
+      throw new Error("App details response did not include app data");
+    }
     return {
       content: [
         {
@@ -199,12 +281,38 @@ var getReviewsSchema = z2.object({
   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"),
+  // The translate endpoint receives the review content in the request body
+  // (it does not re-fetch it). Pass the fields from a get_reviews result.
+  rating: z2.number().int().min(1).max(5).describe("The review star rating, from get_reviews"),
+  title: z2.string().default("").describe("The review title, from get_reviews"),
+  body: z2.string().describe("The review text to translate, from get_reviews"),
+  storeFront: z2.string().default("").describe('The review storefront (e.g. "SE"), from get_reviews'),
+  appVersionString: z2.string().default("").describe("The app version the review was left on, from get_reviews")
+});
 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);
+      const allApps = await client.get("/api/assets", {
+        limit: 100,
+        offset: 0,
+        includeUnvalued: "true"
+      });
+      const match = (allApps.data ?? []).find(
+        (app) => app.bundleId === input.bundleId
+      );
       if (!match) {
         return {
           content: [
@@ -218,12 +326,20 @@ async function getReviews(input, client) {
       }
       assetId = match.id;
     }
+    if (!assetId) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "Provide an assetId (or bundleId) to fetch reviews for. Use list_apps to find app IDs."
+          }
+        ],
+        isError: true
+      };
+    }
     const params = {
-      limit: input.limit,
-      sortBy: input.sortBy
+      limit: input.limit
     };
-    if (assetId)
-      params.assetId = assetId;
     if (input.platform)
       params.platform = input.platform;
     if (input.rating !== void 0)
@@ -234,13 +350,25 @@ async function getReviews(input, client) {
       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 response = await client.get(
+      `/api/assets/${assetId}/reviews`,
+      params
+    );
+    let reviews = response.data?.reviews ?? [];
+    if (input.sortBy === "rating") {
+      reviews = [...reviews].sort(
+        (a, b) => Number(b.rating ?? 0) - Number(a.rating ?? 0)
+      );
+    }
+    const hasReply = (review) => !!(review.developerResponse || review.replySource || review.hasReply);
     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
+      averageRating: reviews.length > 0 ? (reviews.reduce((sum, review) => {
+        const rating = Number(review.rating ?? 0);
+        return sum + (Number.isFinite(rating) ? rating : 0);
+      }, 0) / reviews.length).toFixed(2) : 0,
+      repliedCount: reviews.filter((review) => hasReply(review)).length,
+      unrepliedCount: reviews.filter((review) => !hasReply(review)).length
     };
     return {
       content: [
@@ -248,19 +376,23 @@ async function getReviews(input, client) {
           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
+            reviews: reviews.map((review) => ({
+              id: review.id,
+              appId: review.appId,
+              platform: review.platform,
+              rating: review.rating,
+              title: review.title,
+              // The handler exposes the review text as `review`.
+              body: review.review ?? review.body,
+              author: review.nickname || review.author,
+              // Epoch ms from the handler.
+              date: review.lastModified || review.date,
+              version: review.appVersionString || review.version,
+              storeFront: review.storeFront,
+              hasReply: hasReply(review),
+              replySource: review.replySource ?? null,
+              hasDraft: review.hasDraft ?? false,
+              reply: review.developerResponse ? typeof review.developerResponse === "object" ? review.developerResponse.response : review.developerResponse : review.reply || null
             }))
           })
         }
@@ -278,6 +410,93 @@ async function getReviews(input, client) {
     };
   }
 }
+async function generateReviewReply(input, client) {
+  try {
+    const response = await client.post(
+      `/api/assets/${input.assetId}/reviews/${input.reviewId}/generate-reply`,
+      void 0
+    );
+    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/assets/${input.assetId}/reviews/${input.reviewId}/respond`,
+      // The API handler reads `responseText` from the body.
+      { responseText: 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/assets/${input.assetId}/reviews/${input.reviewId}/translate`,
+      // The translate endpoint expects the review content in the body.
+      {
+        rating: input.rating,
+        title: input.title,
+        review: input.body,
+        storeFront: input.storeFront,
+        appVersionString: input.appVersionString,
+        lastModified: Date.now()
+      }
+    );
+    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";
@@ -337,9 +556,11 @@ var DIMENSION_INFO = {
 };
 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 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 {
@@ -390,10 +611,13 @@ async function getMetrics(input, client) {
     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 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;
@@ -449,17 +673,20 @@ async function discoverDimensions(input, client) {
             assetId: input.assetId,
             dimension: input.dimension,
             displayName: DIMENSION_INFO[input.dimension] || input.dimension,
-            values: response2.data || response2
+            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
-    }));
+    const dimensions = Array.isArray(response.data) ? response.data : [];
+    const enriched = dimensions.map((dim) => {
+      if (typeof dim === "string") {
+        return { name: dim, displayName: DIMENSION_INFO[dim] || dim };
+      }
+      const id = dim.id ?? "";
+      return { name: id, displayName: dim.label ?? DIMENSION_INFO[id] ?? id };
+    });
     return {
       content: [{
         type: "text",
@@ -477,6 +704,9 @@ async function discoverDimensions(input, client) {
 
 // src/tools/agents.ts
 import { z as z4 } from "zod";
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
 var AGENT_TYPES = [
   "review",
   "monitoring",
@@ -507,12 +737,25 @@ var getAgentRunHistorySchema = z4.object({
   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;
+      apiAgents = Array.isArray(response) ? response : response.data ?? response.agents ?? null;
     } catch {
     }
     if (apiAgents && Array.isArray(apiAgents)) {
@@ -562,21 +805,26 @@ async function getAgentDetails(input, client) {
       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)
-          }
-        ]
-      };
+      const response2 = await client.get(`/api/agents/by-type/${input.agentType}`, params);
+      if (response2.agent) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: formatAsJson({
+                agent: response2.agent,
+                recentRuns: response2.recentRuns ?? []
+              })
+            }
+          ]
+        };
+      }
     } catch {
     }
     const response = {
       type: input.agentType,
       description: AGENT_DESCRIPTIONS[input.agentType],
-      message: "Detailed agent configuration is available through the platform dashboard."
+      message: `No ${input.agentType} agent is provisioned for this organization yet. Activate it from the Agents page or with trigger_agent_run once created.`
     };
     return {
       content: [
@@ -600,33 +848,44 @@ async function getAgentDetails(input, client) {
 }
 async function getAgentRunHistory(input, client) {
   try {
+    let agentId;
     try {
-      const params = {
-        limit: input.limit
-      };
+      const byTypeParams = {};
       if (input.assetId)
-        params.assetId = input.assetId;
-      const response = await client.get(`/api/agents/${input.agentType}/runs`, params);
+        byTypeParams.assetId = input.assetId;
+      const byType = await client.get(
+        `/api/agents/by-type/${input.agentType}`,
+        byTypeParams
+      );
+      agentId = byType.agent?.id;
+    } catch {
+    }
+    if (!agentId) {
       return {
         content: [
           {
             type: "text",
             text: formatAsJson({
               agentType: input.agentType,
-              ...response.data || response
+              runs: [],
+              message: `No ${input.agentType} agent is provisioned for this organization yet, so there is no run history.`
             })
           }
         ]
       };
-    } catch {
     }
+    const response = await client.get(
+      `/api/agents/${agentId}/runs`,
+      { limit: input.limit }
+    );
     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.`
+            agentId,
+            ...asRecord(response.data ?? response)
           })
         }
       ]
@@ -643,69 +902,18 @@ async function getAgentRunHistory(input, client) {
     };
   }
 }
-
-// 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")
-});
-async function getAnomalies(input, client) {
+async function triggerAgentRun(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 || [];
+    const body = input.assetId ? { triggerContext: { assetId: input.assetId } } : {};
+    const response = await client.post(
+      `/api/agents/${input.agentId}/run`,
+      body
+    );
     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
-            }))
-          })
+          text: formatAsJson(response.data ?? response)
         }
       ]
     };
@@ -721,51 +929,16 @@ async function getAnomalies(input, client) {
     };
   }
 }
-
-// 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) {
+async function pauseAgent(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 || [];
+    const response = await client.post(
+      `/api/agents/${input.agentId}/pause`
+    );
     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
-            }))
-          })
+          text: formatAsJson(response.data ?? response)
         }
       ]
     };
@@ -781,7 +954,288 @@ async function getAdsPerformance(input, client) {
     };
   }
 }
-
+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;
+    const response = await client.get(
+      "/api/anomalies",
+      params
+    );
+    let anomalies = response.data ?? response.anomalies ?? [];
+    if (input.excludeDismissed && !input.status) {
+      anomalies = anomalies.filter((a) => a.status !== "dismissed");
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson({
+            total: anomalies.length,
+            anomalies: anomalies.map((anomaly) => ({
+              id: anomaly.id,
+              assetId: anomaly.assetId,
+              assetName: anomaly.assetName,
+              assetIcon: anomaly.assetIcon,
+              anomalyDate: anomaly.anomalyDate,
+              metricName: anomaly.metricName,
+              sourceType: anomaly.sourceType,
+              type: anomaly.type,
+              severity: anomaly.severity,
+              actualValue: parseFloat(String(anomaly.actualValue || "0")),
+              expectedValue: parseFloat(String(anomaly.expectedValue || "0")),
+              deviationPercent: parseFloat(
+                String(anomaly.deviationPercent || "0")
+              ),
+              confidence: parseFloat(String(anomaly.confidence || "0")),
+              explanation: anomaly.explanation,
+              suggestedActions: anomaly.suggestedActions,
+              status: anomaly.status,
+              detectedAt: anomaly.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 = {};
+    if (input.assetId)
+      params.assetId = input.assetId;
+    if (input.fromDate)
+      params.from = input.fromDate;
+    if (input.toDate)
+      params.to = input.toDate;
+    const response = await client.get(
+      "/api/ads-agent/campaigns",
+      params
+    );
+    let campaigns = response.data ?? response.campaigns ?? [];
+    if (input.platform) {
+      campaigns = campaigns.filter((c) => c.platform === input.platform);
+    }
+    campaigns = campaigns.slice(0, input.limit);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson({
+            total: campaigns.length,
+            campaigns: campaigns.map((campaign) => ({
+              id: campaign.id,
+              assetId: campaign.assetId,
+              assetName: campaign.assetName,
+              platformCampaignId: campaign.platformCampaignId,
+              name: campaign.name,
+              status: campaign.status,
+              objective: campaign.objective,
+              platform: campaign.platform,
+              linkSource: campaign.linkSource,
+              linkedAt: campaign.linkedAt,
+              totalSpend: campaign.totalSpend ?? null,
+              totalImpressions: campaign.totalImpressions ?? null,
+              totalTaps: campaign.totalTaps ?? null,
+              totalInstalls: campaign.totalInstalls ?? null,
+              avgCPI: campaign.avgCPI ?? null,
+              avgTTR: campaign.avgTTR ?? null,
+              avgCVR: campaign.avgCVR ?? 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({
@@ -841,13 +1295,17 @@ async function getGrowthScore(input, client) {
 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")
+  metric: z8.enum(["proceeds", "total_revenue", "total_downloads", "active_subs", "new_trials"]).describe("The metric to forecast"),
+  forecastWeeks: z8.number().int().min(4).max(156).optional().describe("Weeks to forecast forward (default 104)"),
+  historicalWeeks: z8.number().int().min(12).max(156).optional().describe("Weeks of history to base the forecast on (default 104)")
 });
 async function getForecasts(input, client) {
   try {
     const response = await client.get("/api/forecasting/forecast", {
       assetId: input.assetId,
-      dataPoints: input.dataPoints
+      metricName: input.metric,
+      forecastWeeks: input.forecastWeeks,
+      historicalWeeks: input.historicalWeeks
     });
     return {
       content: [
@@ -872,18 +1330,34 @@ async function getForecasts(input, client) {
 
 // src/tools/dashboard.ts
 import { z as z9 } from "zod";
+function parseDashboardNumber(value) {
+  if (value === null || value === void 0 || value === "")
+    return null;
+  const parsed = typeof value === "number" ? value : Number.parseFloat(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function getSidebarAssets(response) {
+  if (!response)
+    return [];
+  if (Array.isArray(response))
+    return response;
+  return response.data ?? [];
+}
 var getDashboardOverviewSchema = z9.object({});
 async function getDashboardOverview(_input, client) {
   try {
+    const overviewPromise = client.get("/api/dashboard/overview-metrics").catch(() => null);
+    const sidebarPromise = client.get(
+      "/api/dashboard/sidebar-assets"
+    ).catch(() => null);
     const [overviewResponse, sidebarResponse] = await Promise.all([
-      client.get("/api/dashboard/overview-metrics").catch(() => null),
-      client.get("/api/dashboard/sidebar-assets").catch(() => null)
+      overviewPromise,
+      sidebarPromise
     ]);
-    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");
+    const overview = overviewResponse?.data ?? overviewResponse ?? {};
+    const apps = getSidebarAssets(sidebarResponse);
+    const totalValuation = apps.reduce((sum, app) => {
+      return sum + (parseDashboardNumber(app.currentValuation) ?? 0);
     }, 0);
     return {
       content: [
@@ -893,16 +1367,16 @@ async function getDashboardOverview(_input, client) {
             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
+              apps: apps.map((app) => ({
+                id: app.id,
+                name: app.name,
+                bundleId: app.bundleId,
+                platform: app.appleAppId ? "ios" : app.googleAppId ? "android" : "unknown",
+                currentValuation: parseDashboardNumber(app.currentValuation),
+                rating: parseDashboardNumber(app.rating),
+                ratingCount: app.ratingCount ?? null,
+                category: app.category ?? null,
+                iconUrl: app.iconUrl ?? null
               }))
             },
             overview
@@ -925,13 +1399,15 @@ async function getDashboardOverview(_input, client) {
 
 // src/tools/actions.ts
 import { z as z10 } from "zod";
+function asRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
 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")
+  actionId: z10.string().describe("The pending action ID to approve")
 });
 var rejectActionSchema = z10.object({
   actionId: z10.string().describe("The draft reply ID to reject/delete")
@@ -941,10 +1417,16 @@ async function listPendingActions(input, client) {
     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 || [];
+    const response = await client.get(
+      "/api/pending-actions",
+      params
+    );
+    let actions = response.data ?? response.actions ?? [];
+    if (input.assetId) {
+      actions = actions.filter(
+        (action) => action.assetId === input.assetId
+      );
+    }
     return {
       content: [
         {
@@ -970,10 +1452,10 @@ async function listPendingActions(input, client) {
 }
 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);
+    const response = await client.post(
+      `/api/pending-actions/${input.actionId}/approve`,
+      {}
+    );
     return {
       content: [
         {
@@ -983,7 +1465,7 @@ async function approveAction(input, client) {
             actionId: input.actionId,
             status: "approved",
             message: "Reply has been approved and queued for sending",
-            ...response.data || {}
+            ...asRecord2(response.data)
           })
         }
       ]
@@ -1002,7 +1484,9 @@ async function approveAction(input, client) {
 }
 async function rejectAction(input, client) {
   try {
-    const response = await client.post(`/api/pending-actions/${input.actionId}/reject`);
+    const response = await client.post(
+      `/api/pending-actions/${input.actionId}/reject`
+    );
     return {
       content: [
         {
@@ -1012,7 +1496,7 @@ async function rejectAction(input, client) {
             actionId: input.actionId,
             status: "rejected",
             message: "Draft reply has been rejected and removed",
-            ...response.data || {}
+            ...asRecord2(response.data)
           })
         }
       ]
@@ -1030,262 +1514,730 @@ async function rejectAction(input, client) {
   }
 }
 
-// src/server.ts
-async function createMcpServer(config, client) {
-  console.error("[Fload MCP] Server initializing...");
-  const server = new McpServer({
-    name: "fload",
-    version: "0.1.0"
-  });
-  const 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);
+// 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"),
+  cursor: z11.string().optional().describe("Pagination cursor from a previous response (meta.nextCursor)")
+});
+var getAsoLocaleSnapshotsSchema = z11.object({
+  assetId: z11.string().uuid().describe("App UUID to get locale snapshots for"),
+  store: z11.enum(["ios", "android"]).default("ios").describe("Which store listing to read"),
+  locale: z11.string().optional().describe('Filter to a single locale (e.g. "en-US"). Returns all locales if omitted.'),
+  limit: z11.number().int().min(1).max(500).optional().describe("Maximum snapshot rows to return (newest first)")
+});
+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
     };
   }
-  server.registerTool(
-    "list_apps",
-    {
-      description: "List all mobile apps in your Fload organization. Returns app metadata including name, bundle ID, platform (iOS/Android), icon URL, and category.",
-      inputSchema: listAppsSchema.shape
-    },
-    wrapTool("list_apps", listApps)
-  );
-  server.registerTool(
-    "get_app_details",
-    {
-      description: "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.",
-      inputSchema: getAppDetailsSchema.shape
-    },
-    wrapTool("get_app_details", getAppDetails)
-  );
-  server.registerTool(
-    "get_reviews",
-    {
-      description: "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.",
-      inputSchema: getReviewsSchema.shape
-    },
-    wrapTool("get_reviews", getReviews)
-  );
-  server.registerTool(
-    "discover_metrics",
-    {
-      description: "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.",
-      inputSchema: discoverMetricsSchema.shape
-    },
-    wrapTool("discover_metrics", discoverMetrics)
+}
+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,
+      cursor: input.cursor
+    };
+    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/listing-snapshots`,
+      {
+        store: input.store,
+        locale: input.locale,
+        limit: input.limit
+      }
+    );
+    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/refetch`,
+      { force: true }
+    );
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson(response)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatError(error)
+        }
+      ],
+      isError: true
+    };
+  }
+}
+
+// src/tools/chat.ts
+import { randomUUID } from "node:crypto";
+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
+    };
+  }
+}
+function parseUiMessageStream(raw) {
+  let reply = "";
+  const toolsUsed = [];
+  for (const line of raw.split("\n")) {
+    if (!line.startsWith("data:"))
+      continue;
+    const payload = line.slice(5).trim();
+    if (!payload || payload === "[DONE]")
+      continue;
+    try {
+      const event = JSON.parse(payload);
+      if (event.type === "text-delta") {
+        reply += String(event.delta ?? event.textDelta ?? "");
+      } else if (typeof event.type === "string" && event.type === "tool-input-start" && typeof event.toolName === "string") {
+        toolsUsed.push(event.toolName);
+      }
+    } catch {
+    }
+  }
+  return { reply, toolsUsed };
+}
+async function sendChatMessage(input, client) {
+  try {
+    const conversationId = input.conversationId ?? randomUUID();
+    let priorMessages = [];
+    if (input.conversationId) {
+      const history = await client.get(`/api/chat/messages/${input.conversationId}`, { limit: 1e3 });
+      for (const message of history.data ?? []) {
+        const textParts = (message.parts ?? []).filter(
+          (part) => part.type === "text" && typeof part.text === "string"
+        );
+        if (textParts.length === 0)
+          continue;
+        priorMessages.push({
+          id: message.id,
+          role: message.role,
+          parts: textParts
+        });
+      }
+      priorMessages = priorMessages.slice(-100);
+    }
+    const body = {
+      id: conversationId,
+      messages: [
+        ...priorMessages,
+        {
+          id: randomUUID(),
+          role: "user",
+          parts: [{ type: "text", text: input.message }]
+        }
+      ]
+    };
+    if (input.agentType) {
+      body.agentContext = {
+        agentId: null,
+        agentType: input.agentType,
+        agentName: input.agentType,
+        surface: "mcp"
+      };
+    }
+    const raw = await client.postStream("/api/chat", body);
+    const { reply, toolsUsed } = parseUiMessageStream(raw);
+    return {
+      content: [
+        {
+          type: "text",
+          text: formatAsJson({
+            conversationId,
+            reply: reply || "The assistant returned no text response.",
+            toolsUsed,
+            tip: "Pass this conversationId to continue the conversation or to get_conversation_messages for the full transcript."
+          })
+        }
+      ],
+      ...reply ? {} : { isError: true }
+    };
+  } 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(handler) {
+    const callback = 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);
+    };
+    return callback;
+  }
+  function tool(name, title, description, schema, handler, annotations) {
+    server.registerTool(
+      name,
+      {
+        title,
+        description,
+        inputSchema: schema.shape,
+        annotations: { title, ...annotations }
+      },
+      wrapTool(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. Pass the review content fields (rating, title, body, storeFront, appVersionString) from a get_reviews result. Returns the translated text. Does not modify the review in Fload.",
+    translateReviewSchema,
+    translateReview,
+    { readOnlyHint: true, openWorldHint: true }
   );
-  server.registerTool(
+  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",
-    {
-      description: "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.",
-      inputSchema: getMetricsSchema.shape
-    },
-    wrapTool("get_metrics", getMetrics)
+    "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 }
   );
-  server.registerTool(
+  tool(
     "discover_dimensions",
-    {
-      description: "Discover available dimensions for breaking down metrics (e.g., country, platform, app version, campaign). Optionally get the available values for a specific dimension.",
-      inputSchema: discoverDimensionsSchema.shape
-    },
-    wrapTool("discover_dimensions", discoverDimensions)
+    "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 }
   );
-  server.registerTool(
+  tool(
     "list_agents",
-    {
-      description: "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.",
-      inputSchema: listAgentsSchema.shape
-    },
-    wrapTool("list_agents", listAgents)
+    "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 }
   );
-  server.registerTool(
+  tool(
     "get_agent_details",
-    {
-      description: "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.",
-      inputSchema: getAgentDetailsSchema.shape
-    },
-    wrapTool("get_agent_details", getAgentDetails)
+    "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 }
   );
-  server.registerTool(
+  tool(
     "get_agent_run_history",
-    {
-      description: "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.",
-      inputSchema: getAgentRunHistorySchema.shape
-    },
-    wrapTool("get_agent_run_history", getAgentRunHistory)
+    "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 }
   );
-  server.registerTool(
+  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",
-    {
-      description: "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.",
-      inputSchema: getAnomaliesSchema.shape
-    },
-    wrapTool("get_anomalies", getAnomalies)
+    "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 }
   );
-  server.registerTool(
+  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",
-    {
-      description: "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).",
-      inputSchema: getAdsPerformanceSchema.shape
-    },
-    wrapTool("get_ads_performance", getAdsPerformance)
+    "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 }
   );
-  server.registerTool(
+  tool(
     "get_growth_audit",
-    {
-      description: "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.",
-      inputSchema: getGrowthAuditSchema.shape
-    },
-    wrapTool("get_growth_audit", getGrowthAudit)
+    "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 }
   );
-  server.registerTool(
+  tool(
     "get_growth_score",
-    {
-      description: "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.",
-      inputSchema: getGrowthScoreSchema.shape
-    },
-    wrapTool("get_growth_score", getGrowthScore)
+    "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 }
   );
-  server.registerTool(
+  tool(
     "get_forecasts",
-    {
-      description: "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.",
-      inputSchema: getForecastsSchema.shape
-    },
-    wrapTool("get_forecasts", getForecasts)
+    "Get forecasts",
+    "Get a statistical forecast for an app metric (proceeds, total_revenue, total_downloads, active_subs, or new_trials). Returns weekly historical values plus a forward projection with confidence bounds.",
+    getForecastsSchema,
+    getForecasts,
+    { readOnlyHint: true, openWorldHint: false }
   );
-  server.registerTool(
+  tool(
     "get_dashboard_overview",
-    {
-      description: "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).",
-      inputSchema: getDashboardOverviewSchema.shape
-    },
-    wrapTool("get_dashboard_overview", getDashboardOverview)
+    "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 }
   );
-  server.registerTool(
+  tool(
     "list_pending_actions",
-    {
-      description: "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.",
-      inputSchema: listPendingActionsSchema.shape
-    },
-    wrapTool("list_pending_actions", listPendingActions)
+    "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 }
   );
-  server.registerTool(
+  tool(
     "approve_action",
-    {
-      description: "Approve a pending action (e.g., a review draft reply). This marks the reply for sending. Optionally edit the reply text before approving.",
-      inputSchema: approveActionSchema.shape
-    },
-    wrapTool("approve_action", approveAction)
+    "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 }
   );
-  server.registerTool(
+  tool(
     "reject_action",
-    {
-      description: "Reject a pending action (e.g., delete a review draft reply). The draft will be permanently removed.",
-      inputSchema: rejectActionSchema.shape
-    },
-    wrapTool("reject_action", rejectAction)
+    "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 }
   );
-  const toolCount = 18;
-  console.error(`[Fload MCP] Registered ${toolCount} tools`);
+  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 }
+  );
+}
+
+// src/server.ts
+async function createMcpServer(_config, client) {
+  console.error("[Fload MCP] Server initializing...");
+  const server = new McpServer({
+    name: "fload",
+    version: "0.1.0"
+  });
+  registerTools(server, client);
+  console.error("[Fload MCP] Registered tools");
   return server;
 }
 
-// src/api-client.ts
-var FloadApiClient = class {
-  constructor(baseUrl, apiKey) {
-    this.baseUrl = baseUrl;
-    this.apiKey = apiKey;
-  }
-  async request(path, options = {}) {
-    const url = `${this.baseUrl}${path}`;
-    const response = await fetch(url, {
-      ...options,
-      headers: {
-        "Authorization": `Bearer ${this.apiKey}`,
-        "Content-Type": "application/json",
-        ...options.headers
-      }
-    });
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ message: response.statusText }));
-      throw new Error(error.message || `API error: ${response.status}`);
-    }
-    return response.json();
-  }
-  async get(path, params) {
-    const searchParams = new URLSearchParams();
-    if (params) {
-      for (const [key, value] of Object.entries(params)) {
-        if (value !== void 0)
-          searchParams.set(key, String(value));
-      }
-    }
-    const query = searchParams.toString();
-    return this.request(`${path}${query ? `?${query}` : ""}`);
-  }
-  async post(path, body) {
-    return this.request(path, {
-      method: "POST",
-      body: body ? JSON.stringify(body) : void 0
-    });
-  }
-  async patch(path, body) {
-    return this.request(path, {
-      method: "PATCH",
-      body: body ? JSON.stringify(body) : void 0
-    });
-  }
-  async delete(path) {
-    return this.request(path, { method: "DELETE" });
+// src/config.ts
+import "dotenv/config";
+import { readFileSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function loadConfig() {
+  const apiKey = process.env.FLOAD_API_KEY;
+  const apiUrl = process.env.FLOAD_API_URL || "https://api.fload.com";
+  if (apiKey) {
+    return { apiKey, apiUrl };
   }
-};
-
-// src/index.ts
-async function main() {
-  try {
-    console.error("[Fload MCP] Starting server...");
-    const config = loadConfig();
-    console.error("[Fload MCP] Configuration loaded");
-    console.error(`[Fload MCP] API URL: ${config.apiUrl}`);
-    const client = new FloadApiClient(config.apiUrl, config.apiKey);
+  const configPath = join(homedir(), ".fload", "config.json");
+  if (existsSync(configPath)) {
     try {
-      await client.get("/api/assets", { limit: 1, offset: 0 });
-      console.error("[Fload MCP] API connection verified");
+      const configData = JSON.parse(readFileSync(configPath, "utf-8"));
+      if (configData.apiKey) {
+        return {
+          apiKey: configData.apiKey,
+          apiUrl: configData.apiUrl || apiUrl
+        };
+      }
     } catch (error) {
-      console.error("[Fload MCP] Warning: API connection test failed:", error instanceof Error ? error.message : error);
-      console.error("[Fload MCP] Continuing anyway \u2014 API may become available");
+      console.error("Failed to parse config file:", error);
     }
-    const server = await createMcpServer(config, client);
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error("[Fload MCP] Server running on stdio");
-  } catch (error) {
-    console.error("[Fload MCP] Fatal error:", error);
-    process.exit(1);
   }
+  throw new Error(
+    'Fload MCP requires an API key. Set FLOAD_API_KEY environment variable or create ~/.fload/config.json with {"apiKey": "fload_sk_..."}'
+  );
 }
-process.on("SIGINT", () => {
-  console.error("[Fload MCP] Shutting down...");
-  process.exit(0);
-});
-process.on("SIGTERM", () => {
-  console.error("[Fload MCP] Shutting down...");
-  process.exit(0);
-});
-main().catch((error) => {
-  console.error("[Fload MCP] Unhandled error:", error);
-  process.exit(1);
-});
+export {
+  FloadApiClient,
+  RateLimiter,
+  createMcpServer,
+  loadConfig,
+  registerTools
+};
 //# sourceMappingURL=index.js.map