@agent-native/core 0.108.0 → 0.109.1

package/corpus/templates/analytics/server/lib/slack.ts

@@ -9,6 +9,9 @@ export type Workspace = "primary" | "secondary";
 const cache = new Map<string, { data: unknown; ts: number }>();
 const CACHE_TTL_MS = 2 * 60 * 1000; // 2 minutes
 const MAX_CACHE = 200;
+const MAX_CHANNEL_PAGES = 10;
+const MAX_USER_PAGES = 10;
+const SLACK_PAGE_SIZE = 200;
 
 async function getToken(workspace: Workspace): Promise<string> {
   const envKey =
@@ -131,6 +134,41 @@ export interface SlackTeamInfo {
   icon?: { image_68?: string };
 }
 
+export interface SlackPaginationMetadata {
+  cursor_type: "response_metadata" | "latest_ts" | "page" | "none";
+  request_cursor?: string;
+  next_cursor?: string;
+  provider_next_cursor?: string;
+  page?: number;
+  pages?: number;
+  next_page?: number;
+}
+
+export interface SlackCoverageMetadata {
+  requested: number;
+  fetched: number;
+  returned: number;
+  total?: number;
+  pages_fetched: number;
+  coverage_complete: boolean;
+  truncated: boolean;
+  truncation_reasons: string[];
+}
+
+export interface SlackAuthorCoverageMetadata {
+  requested_users: number;
+  resolved_users: number;
+  unresolved_user_ids: string[];
+  requested_bots: number;
+  resolved_bots: number;
+  unresolved_bot_ids: string[];
+  directory_pages_fetched: number;
+  directory_next_cursor?: string;
+  coverage_complete: boolean;
+  truncated: boolean;
+  truncation_reasons: string[];
+}
+
 // User cache (keyed by workspace + userId)
 const userCache = new Map<string, SlackUser>();
 
@@ -165,18 +203,26 @@ export async function getTeamInfo(
   }
 }
 
-export async function listChannels(
+export async function listChannelsWithCoverage(
   workspace: Workspace,
-): Promise<SlackChannel[]> {
+  requestCursor?: string,
+): Promise<{
+  channels: SlackChannel[];
+  total: number;
+  truncated: boolean;
+  pagination: SlackPaginationMetadata;
+  coverage: SlackCoverageMetadata;
+}> {
   const all: SlackChannel[] = [];
-  let cursor: string | undefined;
+  let cursor = requestCursor;
+  let pagesFetched = 0;
 
-  // Paginate through all channels
-  for (let i = 0; i < 10; i++) {
+  // Paginate through the bounded channel directory.
+  for (let i = 0; i < MAX_CHANNEL_PAGES; i++) {
     const params: Record<string, string> = {
       types: "public_channel",
       exclude_archived: "true",
-      limit: "200",
+      limit: String(SLACK_PAGE_SIZE),
     };
     if (cursor) params.cursor = cursor;
 
@@ -186,17 +232,46 @@ export async function listChannels(
     }>(workspace, "conversations.list", params, !cursor); // cache first page only
 
     all.push(...(data.channels || []));
+    pagesFetched += 1;
     cursor = data.response_metadata?.next_cursor;
     if (!cursor) break;
   }
 
-  return all;
+  const truncated = Boolean(cursor);
+  return {
+    channels: all,
+    total: all.length,
+    truncated,
+    pagination: {
+      cursor_type: "response_metadata",
+      ...(requestCursor ? { request_cursor: requestCursor } : {}),
+      ...(cursor ? { next_cursor: cursor } : {}),
+    },
+    coverage: {
+      requested: MAX_CHANNEL_PAGES * SLACK_PAGE_SIZE,
+      fetched: all.length,
+      returned: all.length,
+      pages_fetched: pagesFetched,
+      coverage_complete: !truncated,
+      truncated,
+      truncation_reasons: truncated ? ["page_cap"] : [],
+    },
+  };
+}
+
+export async function listChannels(
+  workspace: Workspace,
+): Promise<SlackChannel[]> {
+  return (await listChannelsWithCoverage(workspace)).channels;
 }
 
 export interface ChannelHistoryResult {
   messages: SlackMessage[];
   has_more: boolean;
   next_cursor?: string; // timestamp of last message
+  truncated: boolean;
+  pagination: SlackPaginationMetadata;
+  coverage: SlackCoverageMetadata;
 }
 
 export async function getChannelHistory(
@@ -215,55 +290,38 @@ export async function getChannelHistory(
     const data = await slackApi<{
       messages: SlackMessage[];
       has_more?: boolean;
+      response_metadata?: { next_cursor?: string };
     }>(workspace, "conversations.history", params, false);
     const messages = data.messages || [];
+    const nextCursor =
+      messages.length > 0 ? messages[messages.length - 1].ts : undefined;
+    const providerNextCursor = data.response_metadata?.next_cursor || undefined;
+    const hasMore = Boolean(data.has_more || providerNextCursor);
     return {
       messages,
-      has_more: !!data.has_more,
-      next_cursor:
-        messages.length > 0 ? messages[messages.length - 1].ts : undefined,
+      has_more: hasMore,
+      next_cursor: nextCursor,
+      truncated: hasMore,
+      pagination: {
+        cursor_type: "latest_ts",
+        ...(cursor ? { request_cursor: cursor } : {}),
+        ...(nextCursor ? { next_cursor: nextCursor } : {}),
+        ...(providerNextCursor
+          ? { provider_next_cursor: providerNextCursor }
+          : {}),
+      },
+      coverage: {
+        requested: Math.min(limit, SLACK_PAGE_SIZE),
+        fetched: messages.length,
+        returned: messages.length,
+        pages_fetched: 1,
+        coverage_complete: !hasMore,
+        truncated: hasMore,
+        truncation_reasons: hasMore ? ["provider_has_more"] : [],
+      },
     };
   } catch (err: any) {
     if (err.message?.includes("not_in_channel")) {
-      // Try to auto-join the channel (requires channels:join scope)
-      try {
-        const token = await getToken(workspace);
-        const joinRes = await fetch(
-          "https://slack.com/api/conversations.join",
-          {
-            method: "POST",
-            headers: {
-              Authorization: `Bearer ${token}`,
-              "Content-Type": "application/json",
-            },
-            body: JSON.stringify({ channel: channelId }),
-          },
-        );
-        const joinData = await joinRes.json();
-        if (joinData.ok) {
-          // Joined successfully, retry history
-          const data = await slackApi<{
-            messages: SlackMessage[];
-            has_more?: boolean;
-          }>(
-            workspace,
-            "conversations.history",
-            {
-              channel: channelId,
-              limit: String(Math.min(limit, 200)),
-            },
-            false,
-          );
-          const msgs = data.messages || [];
-          return {
-            messages: msgs,
-            has_more: !!data.has_more,
-            next_cursor: msgs.length > 0 ? msgs[msgs.length - 1].ts : undefined,
-          };
-        }
-      } catch {
-        // join failed, fall through to friendly error
-      }
       throw new Error(
         "Bot is not in this channel. Please invite the bot to the channel in Slack: " +
           "open the channel, click the channel name, go to Integrations > Add apps, " +
@@ -275,28 +333,35 @@ export async function getChannelHistory(
 }
 
 export async function searchMessages(
-  workspace: Workspace,
-  query: string,
-  count = 50,
-): Promise<{ messages: SlackMessage[]; total: number }> {
-  // search.messages requires a user token, but we'll try with bot token
-  // If it fails, we'll fall back to channel history filtering
-  const data = await slackApi<{
-    messages: { matches: SlackMessage[]; total: number };
-  }>(
-    workspace,
-    "search.messages",
-    {
-      query,
-      count: String(Math.min(count, 100)),
-      sort: "timestamp",
-      sort_dir: "desc",
-    },
-    false,
-  );
+  _workspace: Workspace,
+  _query: string,
+  _count = 50,
+): Promise<{
+  messages: SlackMessage[];
+  total: number;
+  unsupported: true;
+  truncated: boolean;
+  pagination: SlackPaginationMetadata;
+  coverage: SlackCoverageMetadata;
+  guidance: string;
+}> {
   return {
-    messages: data.messages?.matches || [],
-    total: data.messages?.total || 0,
+    messages: [],
+    total: 0,
+    unsupported: true,
+    truncated: true,
+    pagination: { cursor_type: "none" },
+    coverage: {
+      requested: 0,
+      fetched: 0,
+      returned: 0,
+      pages_fetched: 0,
+      coverage_complete: false,
+      truncated: true,
+      truncation_reasons: ["bot_token_global_search_unsupported"],
+    },
+    guidance:
+      "Slack search.messages is unavailable with the configured bot credential. Use conversations.history through the shared Slack corpus recipe for a known channel.",
   };
 }
 
@@ -304,10 +369,7 @@ export async function getUserInfo(
   workspace: Workspace,
   userId: string,
 ): Promise<SlackUser> {
-  const cacheKey = scopedCredentialCacheKey(
-    `${workspace}:${userId}`,
-    workspace === "secondary" ? "SLACK_BOT_TOKEN_2" : "SLACK_BOT_TOKEN",
-  );
+  const cacheKey = slackUserCacheKey(workspace, userId);
   const cached = userCache.get(cacheKey);
   if (cached) return cached;
 
@@ -351,38 +413,81 @@ export async function resolveUsers(
   userIds: string[],
   messages?: SlackMessage[],
 ): Promise<Record<string, SlackUser>> {
+  return (await resolveUsersWithCoverage(workspace, userIds, messages)).users;
+}
+
+export async function resolveUsersWithCoverage(
+  workspace: Workspace,
+  userIds: string[],
+  messages?: SlackMessage[],
+): Promise<{
+  users: Record<string, SlackUser>;
+  coverage: SlackAuthorCoverageMetadata;
+}> {
   const unique = [...new Set(userIds)];
   const results: Record<string, SlackUser> = {};
+  const unresolvedUsers = new Set(unique);
+  let directoryPagesFetched = 0;
+  let directoryNextCursor: string | undefined;
+  let directoryError = false;
+
+  for (const id of unique) {
+    const cacheKey = slackUserCacheKey(workspace, id);
+    const cached = userCache.get(cacheKey);
+    if (!cached) continue;
+    results[id] = cached;
+    unresolvedUsers.delete(id);
+  }
 
-  await Promise.all(
-    unique.map(async (id) => {
-      try {
-        results[id] = await getUserInfo(workspace, id);
-      } catch {
-        results[id] = {
-          id,
-          name: id,
-          real_name: id,
-          profile: { display_name: id, image_48: "", image_72: "" },
-        };
+  try {
+    while (unresolvedUsers.size > 0 && directoryPagesFetched < MAX_USER_PAGES) {
+      const params: Record<string, string> = {
+        limit: String(SLACK_PAGE_SIZE),
+      };
+      if (directoryNextCursor) params.cursor = directoryNextCursor;
+      const data = await slackApi<{
+        members: SlackUser[];
+        response_metadata?: { next_cursor?: string };
+      }>(workspace, "users.list", params, true);
+      directoryPagesFetched += 1;
+
+      for (const user of data.members || []) {
+        userCache.set(slackUserCacheKey(workspace, user.id), user);
+        if (!unresolvedUsers.has(user.id)) continue;
+        results[user.id] = user;
+        unresolvedUsers.delete(user.id);
       }
-    }),
-  );
+
+      directoryNextCursor = data.response_metadata?.next_cursor || undefined;
+      if (!directoryNextCursor) break;
+    }
+  } catch {
+    directoryError = true;
+  }
+
+  const unresolvedUserIds = [...unresolvedUsers];
+  for (const id of unresolvedUserIds) {
+    results[id] = fallbackSlackUser(id);
+  }
 
   // Resolve bot users from messages that have bot_id but no user
+  let resolvedBots = 0;
+  const unresolvedBotIds: string[] = [];
+  const botIds: string[] = [];
   if (messages) {
-    const botIds = [
+    botIds.push(
       ...new Set(
         messages
           .filter((m) => m.bot_id && !results[m.bot_id])
           .map((m) => m.bot_id!),
       ),
-    ];
+    );
 
     await Promise.all(
       botIds.map(async (botId) => {
         try {
           const bot = await getBotInfo(workspace, botId);
+          resolvedBots += 1;
           results[botId] = {
             id: botId,
             name: bot.name,
@@ -394,6 +499,7 @@ export async function resolveUsers(
             },
           };
         } catch {
+          unresolvedBotIds.push(botId);
           // Use the username from the message if available
           const msg = messages.find((m) => m.bot_id === botId);
           results[botId] = {
@@ -411,7 +517,53 @@ export async function resolveUsers(
     );
   }
 
-  return results;
+  const directoryTruncated =
+    unresolvedUsers.size > 0 && Boolean(directoryNextCursor);
+  const coverageComplete =
+    unresolvedUserIds.length === 0 && unresolvedBotIds.length === 0;
+  const truncationReasons = [
+    ...(directoryTruncated ? ["user_directory_page_cap"] : []),
+    ...(directoryError ? ["user_directory_error"] : []),
+    ...(unresolvedUserIds.length > 0 && !directoryTruncated && !directoryError
+      ? ["users_not_found"]
+      : []),
+    ...(unresolvedBotIds.length > 0 ? ["bots_not_found"] : []),
+  ];
+
+  return {
+    users: results,
+    coverage: {
+      requested_users: unique.length,
+      resolved_users: unique.length - unresolvedUserIds.length,
+      unresolved_user_ids: unresolvedUserIds,
+      requested_bots: botIds.length,
+      resolved_bots: resolvedBots,
+      unresolved_bot_ids: unresolvedBotIds,
+      directory_pages_fetched: directoryPagesFetched,
+      ...(directoryNextCursor
+        ? { directory_next_cursor: directoryNextCursor }
+        : {}),
+      coverage_complete: coverageComplete,
+      truncated: !coverageComplete,
+      truncation_reasons: truncationReasons,
+    },
+  };
+}
+
+function slackUserCacheKey(workspace: Workspace, userId: string): string {
+  return scopedCredentialCacheKey(
+    `${workspace}:${userId}`,
+    workspace === "secondary" ? "SLACK_BOT_TOKEN_2" : "SLACK_BOT_TOKEN",
+  );
+}
+
+function fallbackSlackUser(id: string): SlackUser {
+  return {
+    id,
+    name: id,
+    real_name: id,
+    profile: { display_name: id, image_48: "", image_72: "" },
+  };
 }
 
 /**

package/corpus/templates/analytics/server/plugins/agent-chat.ts

@@ -687,7 +687,7 @@ export default createAgentChatPlugin({
   connectorCatalog: [...ANALYTICS_CONNECTOR_CATALOG],
   externalAgents: {
     // Keep the direct MCP surface deliberately curated. External agents
-    // should use ask_app for multi-step investigation; these six actions are
+    // should use ask_app for multi-step investigation; cataloged actions are
     // bounded fallback reads for callers that already know what they need.
     authenticatedReads: "off",
     writes: "ask_app_only",
@@ -704,8 +704,8 @@ export default createAgentChatPlugin({
       analyticsSourceGuidanceOpening() +
       "DASHBOARD CREATION RULE — You may create dashboards, analyses, SQL panels, or other resources only when the user explicitly asks you to (e.g. 'build me a dashboard for...', 'create a new analysis', 'add a chart for...'). Never create any resource proactively during research, trend analysis, or answering questions. If you think a dashboard would be useful, suggest it and wait for explicit confirmation before creating anything. Never add new items to the sidebar or modify existing dashboards without an explicit user directive. " +
       "DASHBOARD MUTATION RULE — For dashboard edits, default to `mutate-dashboard` with the typed `dashboard.*` script API so the main payload is a string and avoids native-array serialization traps. It can move panels by id, edit titles/SQL/config, insert, duplicate, remove, and patch dashboard fields in one atomic save. The script API is constrained: no variables/imports/loops/functions, only JSON-compatible arguments on documented dashboard methods. Do not count shifting `/panels/<index>` positions for ordinary dashboard edits unless the user specifically asks for low-level JSON-pointer operations. " +
-      'DASHBOARD EXTENSION BOX RULE — Analytics dashboards support extension boxes. Insert `chartType: "extension"` panels with `config.extensionSlotId` set to `analytics.dashboard.<dashboard-id>.panel.<panel-id>`, then call `add-extension-slot-target` and `install-extension` with that same id. The install is per-user; the extension box stays on the shared dashboard and receives dashboard/panel/current-filter context. Use `get-sql-dashboard` panel summaries to inspect an existing box; `config.extensionId` is only the legacy direct-embed format. ' +
-      "EXTENSION DATA-REPAIR RULE — When fixing data in an existing extension-backed dashboard or migrated surface such as Risk Meeting, inspect the current dashboard and extension first, then use `update-extension` `patches`/`edits` that change only the data-loading seam. Preserve the existing layout, CSS, copy, and interactions; never reconstruct the full HTML body for a data-only fix. Full-body replacement is blocked unless `allowFullReplacement=true`, which is reserved for an explicit visual rewrite or a complete replacement body supplied by the user. If a focused edit fails, change the target instead of retrying identical arguments. " +
+      'DASHBOARD EXTENSION BOX RULE — Analytics dashboards support extension boxes. For ordinary requests such as "put X in this dashboard," insert a `chartType: "extension"` panel with `config.extensionId`; this author-selected embed is shared with the dashboard, appears in scheduled reports, and receives dashboard/panel/current-filter context. Use `config.extensionSlotId` only when the user explicitly asks for a personal/per-viewer slot. Slot ids use `analytics.dashboard.<dashboard-id>.panel.<panel-id>` and require `add-extension-slot-target` plus `install-extension`; installs are per-user, so viewers can see different content and report identities may see an empty slot. Use `get-sql-dashboard` panel summaries to inspect an existing box. ' +
+      "EXTENSION DATA-REPAIR RULE — When fixing data in an existing extension-backed dashboard or migrated surface such as Risk Meeting, inspect the current dashboard and extension first, then use `update-extension` `patches`/`edits` that change only the data-loading seam. Preserve the existing layout, CSS, copy, and interactions; never reconstruct the full HTML body for a data-only fix. Full-body replacement is blocked unless `allowFullReplacement=true`. A request that combines a visual rewrite such as compacting, removing sections, renaming, or changing padding with a data repair is a broad rewrite; after inspecting the current extension, use `allowFullReplacement=true` for the complete replacement. If a focused edit fails, change the target instead of retrying identical arguments. " +
       'FIRST-PARTY DASHBOARD TIME RULE — AI-generated `source: "first-party"` panels are dashboard-time-bound by default: set `config.timeScope` to `dashboard` and include a matching dashboard time predicate. `{{timeRange}}` requires a matching `filters` entry with `id: "timeRange"` and `type: "select"`; `{{<id>Start}}`/`{{<id>End}}` require a matching `type: "date-range"` filter with that id. Allowed `timeScope` values are `dashboard`, `fixed-window`, `cohort-history`, and `all-time`; use `all-time` only when the user requests full available history and put all-time, lifetime, or historical in the title or description. Server validation rejects unbound first-party SQL. ' +
       "DASHBOARD READ RULE — `get-sql-dashboard` is compact by default: use its `panels` summaries plus `layout.panelOrder`, `layout.firstPanelIds`, and `layout.groups[].rows[].rowNumber/panelIds` for orientation and verification. Pass `includeConfig: true` only when you truly need full panel SQL/config. " +
       'DASHBOARD REORDER RULE — For simple chart/section moves, use `mutate-dashboard` code such as `dashboard.panels(["panel-a","panel-b"]).moveToTop();`. For visible placement requests like "second row" or "next to return rates", use row-aware placement such as `dashboard.insertPanel({...}).nextTo("retention-over-time")`, `.atRow(2)`, or `dashboard.panel("panel-a").moveNextTo("panel-b")`; these keep panels in the intended rendered row and expand/rebalance that row when needed. Never count shifting `/panels/<index>` positions for ordinary \'move this chart\' requests. Use `get-sql-dashboard.layout.groups[].rows` as proof of visible row placement, not only flat `panelOrder`. ' +

package/corpus/templates/analytics/server/routes/api/pylon/accounts.get.ts

@@ -1 +1,42 @@
-export { handlePylonAccounts as default } from "../../../handlers/pylon";
+import { defineEventHandler, getQuery, setResponseStatus } from "h3";
+
+import {
+  requireCredential,
+  runApiHandlerWithContext,
+} from "../../../lib/credentials";
+import { executeProviderApiRequest } from "../../../lib/provider-api";
+
+export default defineEventHandler((event) =>
+  runApiHandlerWithContext(event, async () => {
+    const missing = await requireCredential(event, "PYLON_API_KEY", "Pylon");
+    if (missing) return missing;
+    try {
+      const query = getQuery(event);
+      const search =
+        typeof query.query === "string" && query.query.trim()
+          ? query.query
+          : undefined;
+      const result = (await executeProviderApiRequest({
+        provider: "pylon",
+        method: "GET",
+        path: "/accounts",
+        ...(search ? { query: { query: search } } : {}),
+      })) as { response?: { json?: unknown } };
+      const body = result.response?.json;
+      const accounts =
+        Array.isArray(body) || !body || typeof body !== "object"
+          ? Array.isArray(body)
+            ? body
+            : []
+          : Array.isArray((body as { data?: unknown }).data)
+            ? (body as { data: unknown[] }).data
+            : [];
+      return { accounts, total: accounts.length };
+    } catch (error) {
+      setResponseStatus(event, 500);
+      return {
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }),
+);

package/corpus/templates/analytics/server/routes/api/pylon/issues.get.ts

@@ -1 +1,71 @@
-export { handlePylonIssues as default } from "../../../handlers/pylon";
+import { defineEventHandler, getQuery, setResponseStatus } from "h3";
+
+import pylonIssues from "../../../../actions/pylon-issues";
+import {
+  requireCredential,
+  runApiHandlerWithContext,
+} from "../../../lib/credentials";
+import { executeProviderApiRequest } from "../../../lib/provider-api";
+
+function queryString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value : undefined;
+}
+
+function responseItems(value: unknown): unknown[] {
+  if (Array.isArray(value)) return value;
+  if (value && typeof value === "object" && "data" in value) {
+    const data = (value as { data?: unknown }).data;
+    return Array.isArray(data) ? data : [];
+  }
+  return [];
+}
+
+export default defineEventHandler((event) =>
+  runApiHandlerWithContext(event, async () => {
+    const missing = await requireCredential(event, "PYLON_API_KEY", "Pylon");
+    if (missing) return missing;
+    try {
+      const query = getQuery(event);
+      const accountId = queryString(query.account_id);
+      const state = queryString(query.state);
+      const search = queryString(query.query);
+
+      if (accountId || state || search) {
+        const now = new Date();
+        const start = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1_000);
+        const response = (await executeProviderApiRequest({
+          provider: "pylon",
+          method: "GET",
+          path: "/issues",
+          query: {
+            ...(accountId ? { account_id: accountId } : {}),
+            ...(state ? { state } : {}),
+            ...(search ? { query: search } : {}),
+            start_time: start.toISOString(),
+            end_time: now.toISOString(),
+          },
+        })) as { response?: { json?: unknown } };
+        const issues = responseItems(response.response?.json);
+        return { issues, total: issues.length };
+      }
+
+      const days = queryString(query.days);
+      const parsedDays = days == null ? 371 : Number(days);
+      if (!Number.isInteger(parsedDays) || parsedDays < 1 || parsedDays > 730) {
+        setResponseStatus(event, 400);
+        return { error: "days must be an integer between 1 and 730" };
+      }
+      const result = await pylonIssues.run({
+        days: parsedDays,
+        pageSize: 500,
+        maxPages: 20,
+      });
+      return result;
+    } catch (error) {
+      setResponseStatus(event, 500);
+      return {
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }),
+);

package/corpus/templates/analytics/server/routes/api/test-connection.post.ts

@@ -6,6 +6,7 @@ import {
   resolveCredential,
   withRequestContextFromEvent,
 } from "../../lib/credentials";
+import { executeProviderApiRequest } from "../../lib/provider-api";
 import {
   CLAY_ANALYTICS_CREDENTIAL_KEYS,
   HUBSPOT_ANALYTICS_CREDENTIAL_KEYS,
@@ -13,6 +14,32 @@ import {
   resolveAnalyticsProviderCredential,
 } from "../../lib/provider-credentials";
 
+type ProviderApiConnectionResponse = {
+  response?: {
+    ok?: boolean;
+    status?: number;
+    text?: string;
+    json?: unknown;
+  };
+};
+
+function providerApiConnectionResult(
+  provider: string,
+  result: unknown,
+): { ok: boolean; error?: string } {
+  const response = (result as ProviderApiConnectionResponse).response;
+  if (response?.ok) return { ok: true };
+
+  const detail =
+    response?.text?.trim() ||
+    (response?.json === undefined ? "" : JSON.stringify(response.json));
+  const status = response?.status ?? "unknown";
+  return {
+    ok: false,
+    error: `${provider} API error ${status}${detail ? `: ${detail}` : ""}`,
+  };
+}
+
 export default defineEventHandler(async (event) => {
   const body = await readBody(event);
   const { source } = body as { source?: string };
@@ -66,8 +93,17 @@ export default defineEventHandler(async (event) => {
           const sa = await resolveCredential("MIXPANEL_SERVICE_ACCOUNT", ctx);
           if (!projectId || !sa)
             return { ok: false, error: "Missing credentials" };
-          const { testConnection } = await import("../../lib/mixpanel");
-          return await testConnection();
+          const result = await executeProviderApiRequest({
+            provider: "mixpanel",
+            method: "GET",
+            path: "/events/top",
+            query: {
+              type: "general",
+              limit: 1,
+              project_id: "{projectId}",
+            },
+          });
+          return providerApiConnectionResult("Mixpanel", result);
         }
 
         case "posthog": {
@@ -75,8 +111,12 @@ export default defineEventHandler(async (event) => {
           const projectId = await resolveCredential("POSTHOG_PROJECT_ID", ctx);
           if (!apiKey || !projectId)
             return { ok: false, error: "Missing credentials" };
-          const { testConnection } = await import("../../lib/posthog");
-          return await testConnection();
+          const result = await executeProviderApiRequest({
+            provider: "posthog",
+            method: "GET",
+            path: "/api/projects/{projectId}/",
+          });
+          return providerApiConnectionResult("PostHog", result);
         }
 
         case "postgresql": {