@agent-native/core 0.107.2 → 0.109.0

package/corpus/templates/analytics/actions/slack-messages.ts

@@ -4,9 +4,8 @@ import { z } from "zod";
 import {
   getChannelHistory,
   getTeamInfo,
-  listChannels,
-  resolveUsers,
-  searchMessages,
+  listChannelsWithCoverage,
+  resolveUsersWithCoverage,
   type SlackMessage,
   type Workspace,
 } from "../server/lib/slack";
@@ -41,7 +40,7 @@ function enrichMessages(messages: SlackMessage[]): SlackMessage[] {
 
 export default defineAction({
   description:
-    "Query the analytics app's configured Slack workspace: team info, channels, channel history, multi-channel history, or message search. Slack messages returned by this action are real source evidence; you may count mentions, code themes, classify sentiment, and summarize qualitative patterns from them while stating the sample size.",
+    "Query the analytics app's configured Slack workspace: team info, channels, channel history, or multi-channel history. Slack messages returned by this action are real source evidence; you may count mentions, code themes, classify sentiment, and summarize qualitative patterns from them while stating the sample size. The legacy search mode is preserved for compatibility but returns migration guidance because the configured bot credential cannot call Slack global search; use the Slack provider corpus recipe for channel-scoped exhaustive search.",
   schema: z.object({
     mode: z
       .enum(["team", "channels", "history", "multi-history", "search"])
@@ -68,7 +67,10 @@ export default defineAction({
       .max(200)
       .default(50)
       .describe("Message limit for history"),
-    cursor: z.string().optional().describe("Slack history cursor/latest ts"),
+    cursor: z
+      .string()
+      .optional()
+      .describe("Slack history/latest timestamp or channel-list cursor"),
     cursors: z
       .record(z.string(), z.string())
       .optional()
@@ -99,12 +101,31 @@ export default defineAction({
         const userIds = messages
           .map((message) => message.user)
           .filter((id): id is string => !!id);
-        const users = await resolveUsers(workspace, userIds, messages);
+        const resolution = await resolveUsersWithCoverage(
+          workspace,
+          userIds,
+          messages,
+        );
         return {
           messages,
-          users,
+          users: resolution.users,
           has_more: result.has_more,
           next_cursor: result.next_cursor,
+          truncated: result.truncated,
+          pagination: result.pagination,
+          coverage: {
+            ...result.coverage,
+            coverage_complete:
+              result.coverage.coverage_complete &&
+              resolution.coverage.coverage_complete,
+            truncated:
+              result.coverage.truncated || resolution.coverage.truncated,
+            truncation_reasons: [
+              ...result.coverage.truncation_reasons,
+              ...resolution.coverage.truncation_reasons,
+            ],
+            authors: resolution.coverage,
+          },
         };
       }
 
@@ -113,57 +134,188 @@ export default defineAction({
         const channelIds = args.channels.split(",").filter(Boolean);
         const channelNames = args.names ? args.names.split(",") : channelIds;
         const pageSize = Math.min(args.limit, 200);
-        const results = await Promise.all(
-          channelIds.map((id) =>
-            getChannelHistory(workspace, id, pageSize, args.cursors?.[id]),
+        const channelResults = await Promise.allSettled(
+          channelIds.map((channelId) =>
+            getChannelHistory(
+              workspace,
+              channelId,
+              pageSize,
+              args.cursors?.[channelId],
+            ),
           ),
         );
+        const successfulResults = channelResults.flatMap((entry, index) =>
+          entry.status === "fulfilled"
+            ? [{ channelId: channelIds[index], result: entry.value }]
+            : [],
+        );
+        const failedChannelIds = channelResults.flatMap((entry, index) =>
+          entry.status === "rejected" ? [channelIds[index]] : [],
+        );
 
-        const allMessages: (SlackMessage & { channel_name: string })[] = [];
+        const allMessages: (SlackMessage & {
+          channel_id: string;
+          channel_name: string;
+        })[] = [];
         const perChannelHasMore: Record<string, boolean> = {};
         const nextCursors: Record<string, string> = {};
 
-        results.forEach((result, idx) => {
-          const channelId = channelIds[idx];
+        successfulResults.forEach(({ channelId, result }) => {
           perChannelHasMore[channelId] = result.has_more;
-          if (result.next_cursor) nextCursors[channelId] = result.next_cursor;
           for (const message of result.messages) {
             allMessages.push({
               ...message,
-              channel_name: channelNames[idx] || channelId,
+              channel_id: channelId,
+              channel_name:
+                channelNames[channelIds.indexOf(channelId)] || channelId,
             });
           }
         });
+        failedChannelIds.forEach((channelId) => {
+          perChannelHasMore[channelId] = true;
+        });
 
         allMessages.sort((a, b) => parseFloat(b.ts) - parseFloat(a.ts));
-        const messages = enrichMessages(allMessages.slice(0, pageSize));
+        const pageMessages = allMessages.slice(0, pageSize);
+        const emittedByChannel = new Map<string, SlackMessage[]>();
+        for (const message of pageMessages) {
+          const emitted = emittedByChannel.get(message.channel_id) ?? [];
+          emitted.push(message);
+          emittedByChannel.set(message.channel_id, emitted);
+        }
+        for (const channelId of channelIds) {
+          const emitted = emittedByChannel.get(channelId);
+          const nextCursor = emitted?.[emitted.length - 1]?.ts;
+          if (nextCursor) nextCursors[channelId] = nextCursor;
+          else if (args.cursors?.[channelId]) {
+            nextCursors[channelId] = args.cursors[channelId];
+          }
+        }
+
+        const messages = pageMessages.map((message) => {
+          const enriched = enrichMessages([message])[0] ?? message;
+          const { channel_id: _channelId, ...rest } =
+            enriched as typeof message;
+          return rest;
+        });
         const userIds = messages
           .map((message) => message.user)
           .filter((id): id is string => !!id);
-        const users = await resolveUsers(workspace, userIds, messages);
+        const resolution = await resolveUsersWithCoverage(
+          workspace,
+          userIds,
+          messages,
+        );
+        const providerTruncated = successfulResults.some(
+          ({ result }) => result.truncated,
+        );
+        const mergedResultTruncated = allMessages.length > pageSize;
+        const truncated =
+          providerTruncated ||
+          mergedResultTruncated ||
+          failedChannelIds.length > 0;
+        const truncationReasons = [
+          ...(providerTruncated ? ["provider_has_more"] : []),
+          ...(mergedResultTruncated ? ["merged_result_limit"] : []),
+          ...failedChannelIds.map(
+            (channelId) => `channel_fetch_failed:${channelId}`,
+          ),
+        ];
+        const channelPagination = Object.fromEntries(
+          channelResults.map((entry, index) => [
+            channelIds[index],
+            entry.status === "fulfilled"
+              ? entry.value.pagination
+              : {
+                  cursor_type: "latest_ts" as const,
+                  ...(args.cursors?.[channelIds[index]]
+                    ? { request_cursor: args.cursors[channelIds[index]] }
+                    : {}),
+                },
+          ]),
+        );
+        const channelCoverage = Object.fromEntries(
+          channelResults.map((entry, index) => [
+            channelIds[index],
+            entry.status === "fulfilled"
+              ? entry.value.coverage
+              : {
+                  requested: pageSize,
+                  fetched: 0,
+                  returned: 0,
+                  pages_fetched: 0,
+                  coverage_complete: false,
+                  truncated: true,
+                  truncation_reasons: [
+                    `channel_fetch_failed:${channelIds[index]}`,
+                  ],
+                },
+          ]),
+        );
         return {
           messages,
-          users,
+          users: resolution.users,
           has_more:
             Object.values(perChannelHasMore).some(Boolean) ||
-            allMessages.length > pageSize,
+            allMessages.length > pageSize ||
+            failedChannelIds.length > 0,
           next_cursors: nextCursors,
           total: allMessages.length,
+          truncated,
+          pagination: {
+            cursor_type: "per_channel_latest_ts",
+            request_cursors: args.cursors ?? {},
+            next_cursors: nextCursors,
+            channels: channelPagination,
+          },
+          coverage: {
+            requested: channelIds.length * pageSize,
+            fetched: allMessages.length,
+            returned: messages.length,
+            pages_fetched: successfulResults.length,
+            coverage_complete:
+              !truncated && resolution.coverage.coverage_complete,
+            truncated: truncated || resolution.coverage.truncated,
+            truncation_reasons: [
+              ...truncationReasons,
+              ...resolution.coverage.truncation_reasons,
+            ],
+            channels: channelCoverage,
+            authors: resolution.coverage,
+          },
         };
       }
 
       if (args.mode === "search") {
         if (!args.query) return { error: "query is required" };
-        const result = await searchMessages(workspace, args.query);
-        const userIds = result.messages
-          .map((message) => message.user)
-          .filter((id): id is string => !!id);
-        const users = await resolveUsers(workspace, userIds, result.messages);
-        return { messages: result.messages, users, total: result.total };
+        return {
+          messages: [],
+          users: {},
+          total: 0,
+          unsupported: true,
+          truncated: true,
+          coverage: {
+            requested: 0,
+            fetched: 0,
+            returned: 0,
+            pages_fetched: 0,
+            coverage_complete: false,
+            truncated: true,
+            truncation_reasons: ["bot_token_global_search_unsupported"],
+          },
+          guidance:
+            "Slack global search is not available with the configured bot credential. Resolve a channel id, then use provider-api-catalog(provider='slack') and provider-corpus-job with the Slack conversations.history corpus recipe so cursor pages are fetched inside one resumable operation.",
+        };
       }
 
-      const channels = await listChannels(workspace);
-      return { channels, total: channels.length };
+      const result = await listChannelsWithCoverage(workspace, args.cursor);
+      return {
+        channels: result.channels,
+        total: result.total,
+        truncated: result.truncated,
+        pagination: result.pagination,
+        coverage: result.coverage,
+      };
     } catch (err) {
       return providerError(err);
     }

package/corpus/templates/analytics/actions/view-screen.ts

@@ -456,6 +456,19 @@ export default defineAction({
             "SQL editor",
           ],
         },
+        {
+          id: "flags",
+          label: "Feature flags",
+          path: "/agents?view=flags",
+          adminOnly: true,
+          action: "list-workspace-feature-flags",
+          includes: [
+            "workspace app flag definitions",
+            "rollout state",
+            "exact user and organization targeting",
+            "deterministic percentage rollout",
+          ],
+        },
       ];
       if (screen.agentsView === "dashboards") {
         screen.dashboardUsageStatsAction = "list-dashboard-usage-stats";

package/corpus/templates/analytics/app/components/agents/FeatureFlagsFleetPanel.tsx

@@ -0,0 +1,243 @@
+import {
+  FeatureFlagsEditor,
+  useActionMutation,
+  useActionQuery,
+  useT,
+  type FeatureFlagMetadata,
+  type SetFeatureFlagInput,
+} from "@agent-native/core/client";
+import { IconRefresh } from "@tabler/icons-react";
+import { useQueryClient } from "@tanstack/react-query";
+
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+
+export interface FeatureFlag {
+  key: string;
+  displayName?: string | null;
+  description?: string | null;
+  defaultValue?: boolean;
+  rules?: FeatureFlagMetadata["rules"];
+}
+
+export interface FlagApp {
+  appId?: string;
+  appName?: string;
+  appOrigin?: string;
+  state?: string;
+  id?: string;
+  name?: string;
+  url?: string;
+  status?: string;
+  reason?: string;
+  flags?: FeatureFlag[];
+}
+
+export interface FlagDirectory {
+  directoryStatus?: string;
+  apps?: FlagApp[];
+}
+
+function asDirectory(value: unknown): FlagDirectory {
+  return value && typeof value === "object" ? (value as FlagDirectory) : {};
+}
+
+function isReady(app: FlagApp) {
+  return app.state === "ready" || app.status === "ready";
+}
+
+function statusLabel(app: FlagApp) {
+  return app.state || app.status || "unknown-legacy";
+}
+
+function appId(app: FlagApp) {
+  return app.appId || app.id || "";
+}
+
+function appName(app: FlagApp) {
+  return app.appName || app.name || appId(app);
+}
+
+export function qualifyFleetMutation(
+  appId: string,
+  input: SetFeatureFlagInput,
+) {
+  return { appId, ...input };
+}
+
+export function FeatureFlagsFleetPanel() {
+  const t = useT();
+  const client = useQueryClient();
+  const flags = useActionQuery<unknown>(
+    "list-workspace-feature-flags",
+    undefined,
+    { retry: false },
+  );
+  const mutation = useActionMutation<
+    unknown,
+    { appId: string } & SetFeatureFlagInput
+  >("set-workspace-feature-flag", {
+    onMutate: async (input) => {
+      await client.cancelQueries({
+        queryKey: ["action", "list-workspace-feature-flags"],
+      });
+      const key = ["action", "list-workspace-feature-flags", undefined];
+      const previous = client.getQueryData(key);
+      client.setQueryData(key, (old: unknown) => {
+        const data = asDirectory(old);
+        return {
+          ...data,
+          apps: data.apps?.map((app) =>
+            appId(app) !== input.appId
+              ? app
+              : {
+                  ...app,
+                  flags: app.flags?.map((flag) =>
+                    flag.key !== input.key
+                      ? flag
+                      : {
+                          ...flag,
+                          rules:
+                            input.operation === "replace-rules" && input.rules
+                              ? input.rules
+                              : input.operation === "off"
+                                ? {
+                                    ...flag.rules!,
+                                    mode: "off",
+                                    emails: [],
+                                    orgIds: [],
+                                    percentage: 0,
+                                  }
+                                : flag.rules,
+                        },
+                  ),
+                },
+          ),
+        };
+      });
+      return { previous, key };
+    },
+    onError: (_error, _input, context: any) => {
+      if (context) client.setQueryData(context.key, context.previous);
+    },
+    onSettled: () =>
+      void client.invalidateQueries({
+        queryKey: ["action", "list-workspace-feature-flags"],
+      }),
+  });
+  const directory = asDirectory(flags.data);
+  const apps = directory.apps ?? [];
+  if (flags.isLoading) return <PanelLoading />;
+  if (flags.error || directory.directoryStatus === "unavailable")
+    return (
+      <StatusState
+        title={t("agents.flagsUnavailable")}
+        detail={flags.error?.message || t("agents.flagsUnreachable")}
+        onRetry={() => void flags.refetch()}
+      />
+    );
+  if (apps.length === 0)
+    return (
+      <StatusState
+        title={t("agents.flagsEmpty")}
+        detail={t("agents.flagsEmptyDetail")}
+        onRetry={() => void flags.refetch()}
+      />
+    );
+  return (
+    <div className="flex flex-col gap-4">
+      <div className="flex items-start justify-between gap-3">
+        <div>
+          <h2 className="text-sm font-semibold">{t("agents.featureFlags")}</h2>
+          <p className="mt-1 text-sm text-muted-foreground">
+            {t("agents.featureFlagsDescription")}
+          </p>
+        </div>
+        <Button
+          variant="outline"
+          size="sm"
+          onClick={() => void flags.refetch()}
+        >
+          <IconRefresh className="me-2 size-4" />
+          {t("agents.reloadFlags")}
+        </Button>
+      </div>
+      {apps.map((app) => (
+        <section key={appId(app)} className="overflow-hidden rounded-lg border">
+          <div className="flex items-center justify-between gap-3 border-b bg-muted/30 px-4 py-3">
+            <div>
+              <h3 className="text-sm font-medium">{appName(app)}</h3>
+              {app.reason ? (
+                <p className="text-xs text-muted-foreground">{app.reason}</p>
+              ) : null}
+            </div>
+            {!isReady(app) ? (
+              <Badge variant="outline">{statusLabel(app)}</Badge>
+            ) : null}
+          </div>
+          {isReady(app) ? (
+            <div className="p-4">
+              <FeatureFlagsEditor
+                flags={(app.flags ?? []).filter(
+                  (flag): flag is FeatureFlagMetadata =>
+                    !!flag.rules && typeof flag.defaultValue === "boolean",
+                )}
+                isPending={mutation.isPending}
+                error={
+                  mutation.variables?.appId === appId(app)
+                    ? mutation.error
+                    : null
+                }
+                errorFlagKey={
+                  mutation.variables?.appId === appId(app)
+                    ? mutation.variables.key
+                    : null
+                }
+                showHeader={false}
+                onMutate={(input) =>
+                  mutation.mutate(qualifyFleetMutation(appId(app), input))
+                }
+              />
+            </div>
+          ) : (
+            <div className="p-4 text-sm text-muted-foreground">
+              {statusLabel(app) === "no-definitions"
+                ? t("agents.noFlagDefinitions")
+                : t("agents.flagsNotReady", { status: statusLabel(app) })}
+            </div>
+          )}
+        </section>
+      ))}
+    </div>
+  );
+}
+
+function PanelLoading() {
+  const t = useT();
+  return (
+    <div className="flex min-h-52 items-center justify-center rounded-lg border text-sm text-muted-foreground">
+      {t("agents.loading")}
+    </div>
+  );
+}
+
+function StatusState({
+  title,
+  detail,
+  onRetry,
+}: {
+  title: string;
+  detail: string;
+  onRetry: () => void;
+}) {
+  const t = useT();
+  return (
+    <div className="rounded-lg border p-6">
+      <h2 className="text-sm font-semibold">{title}</h2>
+      <p className="mt-1 text-sm text-muted-foreground">{detail}</p>
+      <Button className="mt-4" size="sm" variant="outline" onClick={onRetry}>
+        {t("sidebar.retry")}
+      </Button>
+    </div>
+  );
+}