@agent-native/core 0.112.0 → 0.113.0

package/corpus/templates/brain/actions/provider-api-request.ts

@@ -1,12 +1,9 @@
-import { defineAction } from "@agent-native/core";
-import { stagingExecuteRequest } from "@agent-native/core/provider-api/staging";
-import { getCredentialContext } from "@agent-native/core/server/request-context";
+import { createProviderApiRequestAction } from "@agent-native/core/provider-api/actions/provider-api";
 import { z } from "zod";
 
 import {
   BRAIN_APP_ID,
   BRAIN_PROVIDER_API_IDS,
-  executeProviderApiRequest,
   getBrainProviderApiRuntime,
 } from "../server/lib/provider-api.js";
 
@@ -68,7 +65,7 @@ const PaginationSchema = z
   })
   .optional();
 
-export default defineAction({
+export default createProviderApiRequestAction(getBrainProviderApiRuntime(), {
   description:
     "Make an arbitrary authenticated HTTP request to a configured or shared provider API for Brain analysis. Use this as the flexible escape hatch when Brain source readers cannot express the needed endpoint, filters, pagination, payload, or API version. The request is constrained to the provider host, uses configured credentials automatically, blocks private/internal URLs, and redacts secrets from responses.",
   schema: z.object({
@@ -198,36 +195,5 @@ export default defineAction({
   }),
   http: false,
   toolCallable: false,
-  run: async (args) => {
-    if (args.stageAs) {
-      const ctx = getCredentialContext();
-      if (!ctx) {
-        throw new Error("No authenticated context for provider API staging.");
-      }
-      const providerRuntime = getBrainProviderApiRuntime();
-      return stagingExecuteRequest(
-        {
-          provider: args.provider,
-          method: args.method,
-          path: args.path,
-          query: args.query,
-          headers: args.headers,
-          body: args.body,
-          auth: args.auth,
-          connectionId: args.connectionId,
-          accountId: args.accountId,
-          timeoutMs: args.timeoutMs,
-          maxBytes: args.maxBytes,
-          stageAs: args.stageAs,
-          itemsPath: args.itemsPath,
-          pagination: args.pagination,
-        },
-        (reqArgs) => providerRuntime.executeRequest(reqArgs),
-        { appId: BRAIN_APP_ID, ownerEmail: ctx.userEmail },
-      );
-    }
-    return executeProviderApiRequest(
-      args as unknown as Parameters<typeof executeProviderApiRequest>[0],
-    );
-  },
+  appId: BRAIN_APP_ID,
 });

package/corpus/templates/brain/actions/query-staged-dataset.ts

@@ -1,13 +1,7 @@
 /**
  * Thin Brain re-export of the staged dataset query helper, pre-bound to appId="brain".
  */
-import { defineAction } from "@agent-native/core";
-import { runAggregateQuery } from "@agent-native/core/provider-api/staged-datasets-aggregate";
-import {
-  getStagedDatasetMeta,
-  getStagedDatasetRows,
-} from "@agent-native/core/provider-api/staged-datasets-store";
-import { getCredentialContext } from "@agent-native/core/server/request-context";
+import { createQueryStagedDatasetAction } from "@agent-native/core/provider-api/actions/staged-datasets";
 import { z } from "zod";
 
 import { BRAIN_APP_ID } from "../server/lib/provider-api.js";
@@ -40,7 +34,7 @@ const AggregateFieldSchema = z.object({
     .describe("Output column name. Default: {op}_{column}."),
 });
 
-export default defineAction({
+export default createQueryStagedDatasetAction({
   description:
     "Run a filter/aggregate/project query over a staged dataset previously written by provider-api-request (stageAs). Use after staging provider source records, messages, transcripts, documents, issues, events, or search results to count, group, filter, or project rows without re-fetching provider APIs.",
   schema: z.object({
@@ -86,44 +80,5 @@ export default defineAction({
       .describe("Maximum rows to return (default all, max 10000)."),
   }),
   http: false,
-  readOnly: true,
-  run: async (args) => {
-    const ctx = getCredentialContext();
-    if (!ctx) {
-      throw new Error("No authenticated context for query-staged-dataset.");
-    }
-
-    const meta = await getStagedDatasetMeta({
-      id: args.datasetId,
-      appId: BRAIN_APP_ID,
-      ownerEmail: ctx.userEmail,
-    });
-    if (!meta) {
-      throw new Error(
-        `Dataset ${args.datasetId} not found (or belongs to a different owner/app).`,
-      );
-    }
-
-    const rows = await getStagedDatasetRows({
-      id: args.datasetId,
-      appId: BRAIN_APP_ID,
-      ownerEmail: ctx.userEmail,
-    });
-
-    const result = runAggregateQuery(rows, {
-      where: args.where,
-      groupBy: args.groupBy,
-      aggregate: args.aggregate,
-      select: args.select,
-      orderBy: args.orderBy,
-      orderDir: args.orderDir,
-      limit: args.limit,
-    });
-
-    return {
-      dataset: { id: meta.id, name: meta.name, totalRows: meta.rowCount },
-      rowCount: result.length,
-      rows: result,
-    };
-  },
+  appId: BRAIN_APP_ID,
 });

package/corpus/templates/brain/actions/update-source.ts

@@ -11,6 +11,7 @@ import {
   stableJson,
 } from "../server/lib/brain.js";
 import { assertSourceWorkspaceConnectionAvailable } from "../server/lib/source-credentials.js";
+import { normalizeSlackChannelConfig } from "../shared/slack-source-config.js";
 import { optionalJsonRecordSchema } from "./_schemas.js";
 
 export default defineAction({
@@ -29,10 +30,13 @@ export default defineAction({
     if (args.title !== undefined) updates.title = args.title;
     if (args.status !== undefined) updates.status = args.status;
     if (args.config !== undefined) {
-      const nextConfig: Record<string, unknown> = {
+      let nextConfig: Record<string, unknown> = {
         ...parseJson<Record<string, unknown>>(existing.configJson, {}),
         ...args.config,
       };
+      if (existing.provider === "slack") {
+        nextConfig = normalizeSlackChannelConfig(nextConfig, args.config);
+      }
       const workspaceConnectionId =
         typeof nextConfig.workspaceConnectionId === "string"
           ? nextConfig.workspaceConnectionId.trim()

package/corpus/templates/brain/app/components/layout/Sidebar.tsx

@@ -10,25 +10,18 @@ import { useT } from "@agent-native/core/client/i18n";
 import { OrgSwitcher } from "@agent-native/core/client/org";
 import { FeedbackButton } from "@agent-native/core/client/ui";
 import {
-  IconArchive,
-  IconDots,
-  IconEdit,
+  ChatHistoryList,
+  type ChatHistoryItem,
+} from "@agent-native/toolkit/chat-history";
+import {
   IconLayoutSidebarLeftCollapse,
   IconLayoutSidebarLeftExpand,
-  IconPin,
   IconPlus,
 } from "@tabler/icons-react";
-import { useEffect, useMemo, useRef, useState, type FormEvent } from "react";
+import { useEffect, useMemo } from "react";
 import { Link, NavLink, useLocation, useNavigate } from "react-router";
 import { toast } from "sonner";
 
-import {
-  DropdownMenu,
-  DropdownMenuContent,
-  DropdownMenuItem,
-  DropdownMenuTrigger,
-} from "@/components/ui/dropdown-menu";
-import { Input } from "@/components/ui/input";
 import {
   Tooltip,
   TooltipContent,
@@ -104,10 +97,6 @@ function BrainChatsSection() {
     autoCreate: false,
     restoreActiveThread: false,
   });
-  const [renamingThreadId, setRenamingThreadId] = useState<string | null>(null);
-  const [renameDraft, setRenameDraft] = useState("");
-  const renameInputRef = useRef<HTMLInputElement | null>(null);
-  const committingRenameRef = useRef(false);
 
   const visibleThreads = useMemo(
     () =>
@@ -117,6 +106,20 @@ function BrainChatsSection() {
         .slice(0, 8),
     [threads],
   );
+  const chatItems = useMemo<ChatHistoryItem[]>(
+    () =>
+      visibleThreads.map((thread) => ({
+        id: thread.id,
+        title: threadTitle(thread),
+        titleText: threadTitle(thread),
+        timestamp:
+          thread.id === activeThreadId
+            ? undefined
+            : formatThreadAge(threadUpdatedAt(thread)),
+        pinned: Boolean(thread.pinnedAt),
+      })),
+    [activeThreadId, visibleThreads],
+  );
 
   useEffect(() => {
     const refresh = () => refreshThreads();
@@ -137,14 +140,6 @@ function BrainChatsSection() {
     };
   }, [refreshThreads]);
 
-  useEffect(() => {
-    if (!renamingThreadId) return;
-    requestAnimationFrame(() => {
-      renameInputRef.current?.focus();
-      renameInputRef.current?.select();
-    });
-  }, [renamingThreadId]);
-
   function openThread(threadId: string, options?: { isNew?: boolean }) {
     switchThread(threadId);
     navigateWithAgentChatViewTransition(navigate, "/");
@@ -175,36 +170,10 @@ function BrainChatsSection() {
     }
   }
 
-  function startRenameThread(thread: ChatThreadSummary) {
-    committingRenameRef.current = false;
-    setRenameDraft(threadTitle(thread));
-    setRenamingThreadId(thread.id);
-  }
-
-  function cancelRenameThread() {
-    committingRenameRef.current = true;
-    setRenamingThreadId(null);
-    setRenameDraft("");
-  }
-
-  async function commitRenameThread() {
-    if (committingRenameRef.current) return;
-    const threadId = renamingThreadId;
-    const title = renameDraft.trim();
-    if (!threadId) return;
-    committingRenameRef.current = true;
-    setRenamingThreadId(null);
-    setRenameDraft("");
-    if (title) {
-      const renamed = await renameThread(threadId, title);
+  function handleRenameThread(threadId: string, title: string) {
+    void renameThread(threadId, title).then((renamed) => {
       if (!renamed) toast.error(t("chat.renameFailed"));
-    }
-    committingRenameRef.current = false;
-  }
-
-  function handleRenameSubmit(event: FormEvent<HTMLFormElement>) {
-    event.preventDefault();
-    void commitRenameThread();
+    });
   }
 
   return (
@@ -227,107 +196,32 @@ function BrainChatsSection() {
           <TooltipContent>{t("chat.newChat")}</TooltipContent>
         </Tooltip>
       </div>
-      <div className="grid gap-0.5">
-        {visibleThreads.map((thread) => {
-          const isActive = thread.id === activeThreadId;
-          const isRenaming = thread.id === renamingThreadId;
-          return (
-            <div
-              key={thread.id}
-              className={cn(
-                "group flex h-8 min-w-0 items-center rounded-md text-sm transition-colors",
-                isActive
-                  ? "bg-sidebar-accent text-sidebar-accent-foreground"
-                  : "text-sidebar-foreground/80 hover:bg-sidebar-accent/65 hover:text-sidebar-accent-foreground",
-              )}
-            >
-              {isRenaming ? (
-                <form
-                  onSubmit={handleRenameSubmit}
-                  className="flex h-full min-w-0 flex-1 items-center px-1.5"
-                >
-                  <Input
-                    ref={renameInputRef}
-                    value={renameDraft}
-                    onChange={(event) => setRenameDraft(event.target.value)}
-                    onBlur={() => void commitRenameThread()}
-                    onKeyDown={(event) => {
-                      if (event.key === "Escape") {
-                        event.preventDefault();
-                        cancelRenameThread();
-                      }
-                    }}
-                    maxLength={160}
-                    aria-label={t("chat.renameThread", {
-                      title: threadTitle(thread),
-                    })}
-                    className="h-6 min-w-0 rounded-sm border-sidebar-border bg-background px-1.5 text-xs"
-                  />
-                </form>
-              ) : (
-                <>
-                  <button
-                    type="button"
-                    onClick={() => openThread(thread.id)}
-                    className="flex h-full min-w-0 flex-1 items-center px-2 text-start outline-none focus-visible:ring-2 focus-visible:ring-ring"
-                  >
-                    <span className="min-w-0 flex-1 truncate">
-                      {threadTitle(thread)}
-                    </span>
-                  </button>
-                  <div className="relative flex size-7 shrink-0 items-center justify-end pe-1">
-                    <span className="text-[11px] text-sidebar-foreground/50 transition-opacity group-hover:opacity-0 group-focus-within:opacity-0">
-                      {isActive ? "" : formatThreadAge(threadUpdatedAt(thread))}
-                    </span>
-                    <DropdownMenu>
-                      <DropdownMenuTrigger asChild>
-                        <button
-                          type="button"
-                          aria-label={t("chat.optionsFor", {
-                            title: threadTitle(thread),
-                          })}
-                          className="absolute end-1 flex size-6 items-center justify-center rounded-md text-sidebar-foreground/65 opacity-0 transition-opacity hover:bg-sidebar-accent hover:text-sidebar-accent-foreground focus-visible:opacity-100 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring group-hover:opacity-100 group-focus-within:opacity-100 data-[state=open]:opacity-100"
-                        >
-                          <IconDots className="size-4" />
-                        </button>
-                      </DropdownMenuTrigger>
-                      <DropdownMenuContent
-                        align="end"
-                        side="right"
-                        sideOffset={6}
-                      >
-                        <DropdownMenuItem
-                          onSelect={() => startRenameThread(thread)}
-                        >
-                          <IconEdit className="size-4" />
-                          {t("chat.renameChat")}
-                        </DropdownMenuItem>
-                        <DropdownMenuItem
-                          onSelect={() =>
-                            void pinThread(thread.id, !thread.pinnedAt)
-                          }
-                        >
-                          <IconPin className="size-4" />
-                          {thread.pinnedAt
-                            ? t("chat.unpinChat")
-                            : t("chat.pinChat")}
-                        </DropdownMenuItem>
-                        <DropdownMenuItem
-                          variant="destructive"
-                          onSelect={() => void handleArchiveThread(thread.id)}
-                        >
-                          <IconArchive className="size-4" />
-                          {t("chat.archiveChat")}
-                        </DropdownMenuItem>
-                      </DropdownMenuContent>
-                    </DropdownMenu>
-                  </div>
-                </>
-              )}
-            </div>
-          );
-        })}
-      </div>
+      {visibleThreads.length > 0 && (
+        <ChatHistoryList
+          items={chatItems}
+          activeId={activeThreadId}
+          onSelect={openThread}
+          onTogglePin={(threadId) => {
+            const thread = visibleThreads.find((item) => item.id === threadId);
+            if (thread) void pinThread(threadId, !thread.pinnedAt);
+          }}
+          onRename={handleRenameThread}
+          renameMaxLength={160}
+          onDelete={(threadId) => void handleArchiveThread(threadId)}
+          labels={{
+            options: (item) =>
+              t("chat.optionsFor", { title: item.titleText ?? "" }),
+            renameInput: (item) =>
+              t("chat.renameThread", { title: item.titleText ?? "" }),
+            rename: t("chat.renameChat"),
+            pin: t("chat.pinChat"),
+            unpin: t("chat.unpinChat"),
+            delete: t("chat.archiveChat"),
+          }}
+          variant="rail"
+          className="min-w-0"
+        />
+      )}
     </div>
   );
 }

package/corpus/templates/brain/app/lib/brain.ts

@@ -142,6 +142,11 @@ export interface BrainSource {
   } | null;
 }
 
+export interface CreateSourceResponse {
+  source: BrainSource;
+  ingestToken?: string;
+}
+
 export interface BrainOverviewResponse {
   metrics?: BrainMetric[];
   reviewQueue?: ReviewItem[];
@@ -304,6 +309,25 @@ export interface BrainHealthResponse {
     lastCapturedAt?: string | null;
     counts?: Record<string, number>;
   };
+  privacy: {
+    classifier: {
+      configured: boolean;
+      model: string | null;
+      engine: string | null;
+      warning: string | null;
+    };
+    events: {
+      total: number;
+      suppressed: number;
+      quarantined: number;
+      released: number;
+      discarded: number;
+      expired: number;
+      counts?: Record<string, number>;
+      confidenceCounts?: Record<string, number>;
+    };
+    policyVersion: string;
+  };
   proposals: {
     pending: number;
     approved: number;
@@ -326,6 +350,37 @@ export interface BrainHealthResponse {
     total: number;
     counts?: Record<string, number>;
   };
+  searchIndex: {
+    indexVersion: string;
+    coverage: {
+      eligibleCaptures: number;
+      activeArtifacts: number;
+      indexedCaptures: number;
+      missingCaptures: number;
+      percent: number;
+    };
+    artifacts: {
+      total: number;
+      active: number;
+      stale: number;
+      deleted: number;
+      counts?: Record<string, number>;
+    };
+    embeddings: {
+      total: number;
+      active: number;
+      stale: number;
+      deleted: number;
+      counts?: Record<string, number>;
+    };
+    queue: {
+      pending: number;
+      failed: number;
+      stale: number;
+      total: number;
+      counts?: Record<string, number>;
+    };
+  };
   retrieval: {
     lastEval?: {
       mode: "product-demo" | "retrieval" | string;

package/corpus/templates/brain/app/lib/ingest-handoff.ts

@@ -0,0 +1,35 @@
+import type { BrainSource, CreateSourceResponse } from "./brain";
+
+export const BRAIN_INGEST_PATH = "/api/_agent-native/brain/ingest";
+
+export interface OneTimeIngestHandoff {
+  endpoint: string;
+  ingestToken: string;
+  provider: "clips" | "generic";
+  source: BrainSource;
+  sourceKey: string;
+}
+
+export function createOneTimeIngestHandoff({
+  origin,
+  provider,
+  result,
+  sourceKey,
+}: {
+  origin: string;
+  provider: string;
+  result: CreateSourceResponse;
+  sourceKey: string;
+}): OneTimeIngestHandoff | null {
+  if (provider !== "clips" && provider !== "generic") return null;
+  const ingestToken = result.ingestToken?.trim();
+  const normalizedSourceKey = sourceKey.trim();
+  if (!ingestToken || !normalizedSourceKey) return null;
+  return {
+    endpoint: new URL(BRAIN_INGEST_PATH, origin).toString(),
+    ingestToken,
+    provider,
+    source: result.source,
+    sourceKey: normalizedSourceKey,
+  };
+}

package/corpus/templates/brain/changelog/2026-07-19-slack-backfills-can-now-join-configured-public-channels-befo.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-19
+---
+
+Slack backfills can now join configured public channels before reading their history.

package/corpus/templates/brain/changelog/2026-07-19-slack-backfills-now-continue-across-the-configured-number-of.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-19
+---
+
+Slack backfills now continue across the configured number of history pages.

package/corpus/templates/brain/changelog/2026-07-19-slack-backfills-now-start-with-a-safe-four-week-window-and-r.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-19
+---
+
+Slack backfills now start with a safe four-week window and resume across bounded channel pages

package/corpus/templates/brain/server/lib/connectors.ts

@@ -18,6 +18,10 @@ import {
   serializeCapture,
   stableJson,
 } from "./brain.js";
+import {
+  ensureSlackPublicChannelMembership,
+  type SlackChannelJoinResponse,
+} from "./slack-channel-membership.js";
 import {
   inspectSourceCredentialAvailability,
   resolveSourceCredential,
@@ -182,6 +186,7 @@ interface SlackChannel {
   is_group?: boolean;
   is_archived?: boolean;
   is_private?: boolean;
+  is_member?: boolean;
 }
 
 interface SlackMessage {
@@ -847,10 +852,31 @@ async function slackApi<T>(
   token: string,
   method: string,
   params: Record<string, string | number | boolean | null | undefined> = {},
+  options: {
+    httpMethod?: "GET" | "POST";
+    toleratedErrors?: readonly string[];
+  } = {},
 ): Promise<T> {
-  const url = buildUrl(`https://slack.com/api/${method}`, params);
+  const httpMethod = options.httpMethod ?? "GET";
+  const url = buildUrl(
+    `https://slack.com/api/${method}`,
+    httpMethod === "GET" ? params : {},
+  );
+  const body = new URLSearchParams();
+  if (httpMethod === "POST") {
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== null && value !== undefined) body.set(key, String(value));
+    }
+  }
   const response = await fetch(url.toString(), {
-    headers: { Authorization: `Bearer ${token}` },
+    method: httpMethod,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      ...(httpMethod === "POST"
+        ? { "Content-Type": "application/x-www-form-urlencoded" }
+        : {}),
+    },
+    ...(httpMethod === "POST" ? { body } : {}),
   });
   if (response.status === 429) {
     throw new ConnectorRateLimitError(
@@ -872,6 +898,9 @@ async function slackApi<T>(
     if (data.error === "ratelimited") {
       throw new ConnectorRateLimitError("slack", method, 60);
     }
+    if (data.error && options.toleratedErrors?.includes(data.error)) {
+      return data as T;
+    }
     const details = [
       data.needed ? `needed: ${data.needed}` : null,
       data.provided ? `provided: ${data.provided}` : null,
@@ -2188,6 +2217,8 @@ async function syncSlack(source: SourceRow): Promise<ConnectorSyncResult> {
     capturesCreated: 0,
     threadsFetched: 0,
     sensitivityBlocked: 0,
+    publicChannelsJoined: 0,
+    publicChannelsAlreadyJoined: 0,
     rateLimited: false,
   };
 
@@ -2269,6 +2300,25 @@ async function syncSlack(source: SourceRow): Promise<ConnectorSyncResult> {
     let permalinkCalls = 0;
 
     for (const channel of channelsToScan) {
+      const membership = await ensureSlackPublicChannelMembership(
+        channel,
+        (channelId) =>
+          slackApi<SlackChannelJoinResponse>(
+            token,
+            "conversations.join",
+            { channel: channelId },
+            {
+              httpMethod: "POST",
+              toleratedErrors: ["already_in_channel"],
+            },
+          ),
+      );
+      if (membership === "joined") {
+        stats.publicChannelsJoined = Number(stats.publicChannelsJoined) + 1;
+      } else if (membership === "already_member") {
+        stats.publicChannelsAlreadyJoined =
+          Number(stats.publicChannelsAlreadyJoined) + 1;
+      }
       const privateMemberEmails = channel.is_private
         ? await slackPrivateChannelMemberEmails(
             token,
@@ -2352,6 +2402,7 @@ async function syncSlack(source: SourceRow): Promise<ConnectorSyncResult> {
         if (data.has_more && nextPage) {
           channelCursor.pageCursor = nextPage;
           nextCursor.channels![channel.id] = channelCursor;
+          if (page + 1 < pagesPerChannel) continue;
           break;
         }
 

package/corpus/templates/brain/server/lib/slack-channel-membership.ts

@@ -0,0 +1,44 @@
+export interface SlackChannelMembershipTarget {
+  id: string;
+  is_im?: boolean;
+  is_mpim?: boolean;
+  is_channel?: boolean;
+  is_group?: boolean;
+  is_private?: boolean;
+  is_member?: boolean;
+}
+
+export interface SlackChannelJoinResponse {
+  ok?: boolean;
+  error?: string;
+}
+
+export type SlackChannelMembershipResult =
+  | "not_public"
+  | "membership_unknown"
+  | "already_member"
+  | "joined";
+
+export async function ensureSlackPublicChannelMembership(
+  channel: SlackChannelMembershipTarget,
+  joinChannel: (channelId: string) => Promise<SlackChannelJoinResponse>,
+): Promise<SlackChannelMembershipResult> {
+  if (
+    channel.is_private === true ||
+    channel.is_group === true ||
+    channel.is_im === true ||
+    channel.is_mpim === true ||
+    channel.is_channel === false
+  ) {
+    return "not_public";
+  }
+  if (channel.is_member === true) return "already_member";
+  if (channel.is_member !== false) return "membership_unknown";
+
+  const result = await joinChannel(channel.id);
+  if (result.ok !== false) return "joined";
+  if (result.error === "already_in_channel") return "already_member";
+  throw new Error(
+    `Slack conversations.join failed: ${result.error ?? "unknown"}`,
+  );
+}