@tablestore/tablestore-agent-cli 0.1.8 → 0.2.0

package/dist/dashboard-runtime/dashboard/src/hooks/use-chat-history.ts

@@ -1,15 +1,20 @@
 "use client";
 
-import { useCallback, useSyncExternalStore } from "react";
+import { useCallback, useMemo, useSyncExternalStore } from "react";
 
 import type { ChatMessage } from "@/types/llm-chat";
 
-/** localStorage key for the serialized session list. Bumping the suffix lets
- * us invalidate incompatible historical blobs in future migrations. */
-export const CHAT_HISTORY_STORAGE_KEY = "tsagent.chat.sessions.v1";
+/** Legacy global key kept for read-only migration. */
+export const CHAT_HISTORY_LEGACY_STORAGE_KEY = "tsagent.chat.sessions.v1";
+/** Backwards-compatible alias for older tests/imports. */
+export const CHAT_HISTORY_STORAGE_KEY = CHAT_HISTORY_LEGACY_STORAGE_KEY;
+/** v2 stores sessions under a project-scoped localStorage key. */
+export const CHAT_HISTORY_STORAGE_KEY_PREFIX = "tsagent.chat.sessions.v2";
 
-/** Soft cap on the number of retained sessions; the oldest ones are dropped
- * on upsert to keep localStorage usage bounded. */
+const UNBOUND_SCOPE = "unbound";
+
+/** Soft cap on the number of retained sessions per project; the oldest ones
+ * are dropped on upsert to keep localStorage usage bounded. */
 const MAX_SESSIONS = 50;
 
 /** Upper bound on messages preserved per session. Long-running chats would
@@ -29,8 +34,8 @@ const TITLE_MAX_LENGTH = 24;
  * NOTE: previous versions of this schema carried `retrievalConfiguration` and
  * `topK` on each mount; both fields were dropped in favour of a single
  * session-wide retrieval config, because per-mount scoring makes the global
- * aggregate ranking meaningless. The `readAll` path tolerates and migrates
- * legacy entries silently. */
+ * aggregate ranking meaningless. The read path tolerates and migrates legacy
+ * entries silently. */
 export interface ChatSessionMount {
   id: string;
   knowledgeBaseName: string;
@@ -70,54 +75,98 @@ export interface ChatSession {
   id: string;
   title: string;
   updatedAt: number;
-  /** Active instance at the time of the last save; used to scope history when
-   * the user switches instances. */
+  /** Active project at the time of the save. `null` means raw-token/env mode. */
   activeInstance?: string | null;
   config: ChatSessionConfig;
   messages: ChatMessage[];
 }
 
+export interface ChatHistoryScope {
+  activeInstance: string | null;
+  ready: boolean;
+}
+
 // ---------------------------------------------------------------------------
-// Low-level storage access (SSR-safe).
+// Scope + migration helpers
 // ---------------------------------------------------------------------------
 
-function readAll(): ChatSession[] {
+function normalizeActiveInstance(activeInstance: string | null | undefined) {
+  return activeInstance && activeInstance.length > 0 ? activeInstance : null;
+}
+
+function scopeSuffix(activeInstance: string | null | undefined): string {
+  const normalized = normalizeActiveInstance(activeInstance);
+  return normalized ? `project.${encodeURIComponent(normalized)}` : UNBOUND_SCOPE;
+}
+
+export function getChatHistoryStorageKey(
+  activeInstance: string | null | undefined,
+): string {
+  return `${CHAT_HISTORY_STORAGE_KEY_PREFIX}.${scopeSuffix(activeInstance)}`;
+}
+
+function belongsToScope(
+  session: ChatSession,
+  activeInstance: string | null | undefined,
+): boolean {
+  return (
+    normalizeActiveInstance(session.activeInstance) ===
+    normalizeActiveInstance(activeInstance)
+  );
+}
+
+function sanitizeSessions(parsed: unknown): ChatSession[] {
+  if (!Array.isArray(parsed)) return [];
+  const sessions = parsed.filter(
+    (s): s is ChatSession =>
+      !!s &&
+      typeof s === "object" &&
+      typeof (s as ChatSession).id === "string" &&
+      Array.isArray((s as ChatSession).messages),
+  );
+  return sessions.map((s) => ({
+    ...s,
+    activeInstance: normalizeActiveInstance(s.activeInstance),
+    config: {
+      ...s.config,
+      mounts: (s.config?.mounts ?? []).map((m) => ({
+        id: m.id,
+        knowledgeBaseName: m.knowledgeBaseName,
+        ...(m.subspace && m.subspace.length ? { subspace: m.subspace } : {}),
+      })),
+    },
+  }));
+}
+
+function readStorageKey(storageKey: string): ChatSession[] {
   if (typeof window === "undefined") return [];
   try {
-    const raw = window.localStorage.getItem(CHAT_HISTORY_STORAGE_KEY);
+    const raw = window.localStorage.getItem(storageKey);
     if (!raw) return [];
-    const parsed = JSON.parse(raw) as unknown;
-    if (!Array.isArray(parsed)) return [];
-    // Defensive: filter out entries missing required fields, which can happen
-    // if an older schema leaked through.
-    const sessions = parsed.filter(
-      (s): s is ChatSession =>
-        !!s &&
-        typeof s === "object" &&
-        typeof (s as ChatSession).id === "string" &&
-        Array.isArray((s as ChatSession).messages),
-    );
-    // Migration (read-only, not persisted back): drop per-mount
-    // `retrievalConfiguration` and `topK` fields. These were stored by
-    // earlier builds and are no longer meaningful now that retrieval params
-    // live at the session level. The on-disk blob is only rewritten on the
-    // next `upsertSession`, so we avoid a thundering-herd write on load.
-    return sessions.map((s) => ({
-      ...s,
-      config: {
-        ...s.config,
-        mounts: (s.config?.mounts ?? []).map((m) => ({
-          id: m.id,
-          knowledgeBaseName: m.knowledgeBaseName,
-          ...(m.subspace && m.subspace.length ? { subspace: m.subspace } : {}),
-        })),
-      },
-    }));
+    return sanitizeSessions(JSON.parse(raw));
   } catch {
     return [];
   }
 }
 
+function migrateLegacyIfNeeded(activeInstance: string | null): void {
+  if (typeof window === "undefined") return;
+  const scopedKey = getChatHistoryStorageKey(activeInstance);
+  if (window.localStorage.getItem(scopedKey) !== null) return;
+  const migrated = readStorageKey(CHAT_HISTORY_LEGACY_STORAGE_KEY).filter((s) =>
+    belongsToScope(s, activeInstance),
+  );
+  if (migrated.length === 0) return;
+  writeStorageKey(scopedKey, migrated);
+}
+
+function readAll(activeInstance: string | null): ChatSession[] {
+  migrateLegacyIfNeeded(activeInstance);
+  return readStorageKey(getChatHistoryStorageKey(activeInstance)).filter((s) =>
+    belongsToScope(s, activeInstance),
+  );
+}
+
 function isQuotaError(err: unknown): boolean {
   // Firefox uses `NS_ERROR_DOM_QUOTA_REACHED`, Safari/Chrome use
   // `QuotaExceededError`; both surface as a DOMException with one of those
@@ -129,7 +178,16 @@ function isQuotaError(err: unknown): boolean {
   );
 }
 
-function writeAll(sessions: ChatSession[]): void {
+function dispatchStorageEvent(storageKey: string): void {
+  if (typeof window === "undefined") return;
+  try {
+    window.dispatchEvent(new StorageEvent("storage", { key: storageKey }));
+  } catch {
+    window.dispatchEvent(new Event("storage"));
+  }
+}
+
+function writeStorageKey(storageKey: string, sessions: ChatSession[]): void {
   if (typeof window === "undefined") return;
   // Try the full list first; on quota failure, progressively drop the
   // oldest sessions and retry. We bottom out at the newest single session
@@ -139,12 +197,10 @@ function writeAll(sessions: ChatSession[]): void {
   for (let attempt = 0; attempt < 3; attempt += 1) {
     try {
       const serialized = JSON.stringify(remaining);
-      window.localStorage.setItem(CHAT_HISTORY_STORAGE_KEY, serialized);
+      window.localStorage.setItem(storageKey, serialized);
       // Manually dispatch so same-tab subscribers react without relying on
       // the native `storage` event, which only fires cross-tab.
-      window.dispatchEvent(
-        new StorageEvent("storage", { key: CHAT_HISTORY_STORAGE_KEY }),
-      );
+      dispatchStorageEvent(storageKey);
       return;
     } catch (err) {
       if (!isQuotaError(err) || remaining.length <= 1) {
@@ -154,13 +210,17 @@ function writeAll(sessions: ChatSession[]): void {
       }
       // Drop the oldest quarter and retry. `remaining` is assumed sorted
       // newest-first by the caller (`upsertSession` trims and sorts
-      // before calling writeAll).
+      // before calling writeStorageKey).
       const keep = Math.max(1, Math.floor(remaining.length * 0.75));
       remaining = remaining.slice(0, keep);
     }
   }
 }
 
+function writeAll(activeInstance: string | null, sessions: ChatSession[]): void {
+  writeStorageKey(getChatHistoryStorageKey(activeInstance), sessions);
+}
+
 // ---------------------------------------------------------------------------
 // Pure helpers
 // ---------------------------------------------------------------------------
@@ -176,26 +236,38 @@ export function deriveSessionTitle(messages: ChatMessage[]): string {
     : clean;
 }
 
-export function listSessions(): ChatSession[] {
+export function listSessions(
+  activeInstance: string | null | undefined,
+): ChatSession[] {
   // Always return sorted by updatedAt desc so the sidebar can render directly.
-  return readAll().sort((a, b) => b.updatedAt - a.updatedAt);
+  return readAll(normalizeActiveInstance(activeInstance)).sort(
+    (a, b) => b.updatedAt - a.updatedAt,
+  );
 }
 
-export function getSession(id: string): ChatSession | null {
-  return readAll().find((s) => s.id === id) ?? null;
+export function getSession(
+  id: string,
+  activeInstance: string | null | undefined,
+): ChatSession | null {
+  return listSessions(activeInstance).find((s) => s.id === id) ?? null;
 }
 
-export function upsertSession(session: ChatSession): void {
-  const all = readAll();
+export function upsertSession(
+  session: ChatSession,
+  activeInstance: string | null | undefined,
+): void {
+  const scope = normalizeActiveInstance(activeInstance);
+  const all = readAll(scope);
   // Truncate the session's message list to the tail so a single runaway
   // conversation cannot consume the whole localStorage budget.
+  const scopedSession = { ...session, activeInstance: scope };
   const capped: ChatSession =
-    session.messages.length > MAX_MESSAGES_PER_SESSION
+    scopedSession.messages.length > MAX_MESSAGES_PER_SESSION
       ? {
-          ...session,
-          messages: session.messages.slice(-MAX_MESSAGES_PER_SESSION),
+          ...scopedSession,
+          messages: scopedSession.messages.slice(-MAX_MESSAGES_PER_SESSION),
         }
-      : session;
+      : scopedSession;
   const idx = all.findIndex((s) => s.id === capped.id);
   if (idx >= 0) {
     all[idx] = capped;
@@ -206,16 +278,22 @@ export function upsertSession(session: ChatSession): void {
   const trimmed = all
     .sort((a, b) => b.updatedAt - a.updatedAt)
     .slice(0, MAX_SESSIONS);
-  writeAll(trimmed);
+  writeAll(scope, trimmed);
 }
 
-export function deleteSession(id: string): void {
-  const all = readAll().filter((s) => s.id !== id);
-  writeAll(all);
+export function deleteSession(
+  id: string,
+  activeInstance: string | null | undefined,
+): void {
+  const scope = normalizeActiveInstance(activeInstance);
+  const all = readAll(scope).filter((s) => s.id !== id);
+  writeAll(scope, all);
 }
 
-export function clearAllSessions(): void {
-  writeAll([]);
+export function clearAllSessions(
+  activeInstance: string | null | undefined,
+): void {
+  writeAll(normalizeActiveInstance(activeInstance), []);
 }
 
 // ---------------------------------------------------------------------------
@@ -223,42 +301,44 @@ export function clearAllSessions(): void {
 // ---------------------------------------------------------------------------
 
 type Listener = () => void;
-const listeners = new Set<Listener>();
 
-function subscribe(listener: Listener): () => void {
-  listeners.add(listener);
+function subscribeToStorageKey(
+  storageKey: string | null,
+  listener: Listener,
+): () => void {
+  if (!storageKey || typeof window === "undefined") return () => {};
   const handler = (event: StorageEvent) => {
-    if (event.key && event.key !== CHAT_HISTORY_STORAGE_KEY) return;
+    if (event.key && event.key !== storageKey) return;
     listener();
   };
-  if (typeof window !== "undefined") {
-    window.addEventListener("storage", handler);
-  }
+  window.addEventListener("storage", handler);
   return () => {
-    listeners.delete(listener);
-    if (typeof window !== "undefined") {
-      window.removeEventListener("storage", handler);
-    }
+    window.removeEventListener("storage", handler);
   };
 }
 
-// Cache the last snapshot so `useSyncExternalStore` can return a stable
-// reference when nothing changed — otherwise React warns about snapshot
-// identity churn on every render.
-let cachedSnapshot: ChatSession[] = [];
-let cachedRaw = "";
-
-function getSnapshot(): ChatSession[] {
-  if (typeof window === "undefined") return cachedSnapshot;
-  const raw = window.localStorage.getItem(CHAT_HISTORY_STORAGE_KEY) ?? "";
-  if (raw === cachedRaw) return cachedSnapshot;
-  cachedRaw = raw;
-  cachedSnapshot = listSessions();
-  return cachedSnapshot;
+// Cache snapshots per storage key so `useSyncExternalStore` can return a
+// stable reference when nothing changed.
+const snapshotCache = new Map<string, { raw: string; snapshot: ChatSession[] }>();
+const EMPTY_SESSIONS: ChatSession[] = [];
+
+function getSnapshotFor(
+  activeInstance: string | null,
+  ready: boolean,
+): ChatSession[] {
+  if (!ready || typeof window === "undefined") return EMPTY_SESSIONS;
+  migrateLegacyIfNeeded(activeInstance);
+  const storageKey = getChatHistoryStorageKey(activeInstance);
+  const raw = window.localStorage.getItem(storageKey) ?? "";
+  const cached = snapshotCache.get(storageKey);
+  if (cached?.raw === raw) return cached.snapshot;
+  const snapshot = listSessions(activeInstance);
+  snapshotCache.set(storageKey, { raw, snapshot });
+  return snapshot;
 }
 
 function getServerSnapshot(): ChatSession[] {
-  return [];
+  return EMPTY_SESSIONS;
 }
 
 export interface UseChatHistoryResult {
@@ -269,19 +349,52 @@ export interface UseChatHistoryResult {
   get(id: string): ChatSession | null;
 }
 
-export function useChatHistory(): UseChatHistoryResult {
-  const sessions = useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+export function useChatHistory(scope: ChatHistoryScope): UseChatHistoryResult {
+  const activeInstance = normalizeActiveInstance(scope.activeInstance);
+  const storageKey = scope.ready
+    ? getChatHistoryStorageKey(activeInstance)
+    : null;
+
+  const subscribe = useCallback(
+    (listener: Listener) => subscribeToStorageKey(storageKey, listener),
+    [storageKey],
+  );
+  const getSnapshot = useCallback(
+    () => getSnapshotFor(activeInstance, scope.ready),
+    [activeInstance, scope.ready],
+  );
+  const sessions = useSyncExternalStore(
+    subscribe,
+    getSnapshot,
+    getServerSnapshot,
+  );
 
-  const upsert = useCallback((session: ChatSession) => {
-    upsertSession(session);
-  }, []);
-  const remove = useCallback((id: string) => {
-    deleteSession(id);
-  }, []);
+  const upsert = useCallback(
+    (session: ChatSession) => {
+      if (!scope.ready) return;
+      upsertSession(session, activeInstance);
+    },
+    [activeInstance, scope.ready],
+  );
+  const remove = useCallback(
+    (id: string) => {
+      if (!scope.ready) return;
+      deleteSession(id, activeInstance);
+    },
+    [activeInstance, scope.ready],
+  );
   const clear = useCallback(() => {
-    clearAllSessions();
-  }, []);
-  const get = useCallback((id: string) => getSession(id), []);
+    if (!scope.ready) return;
+    clearAllSessions(activeInstance);
+  }, [activeInstance, scope.ready]);
+  const get = useCallback(
+    (id: string) =>
+      scope.ready ? getSession(id, activeInstance) : null,
+    [activeInstance, scope.ready],
+  );
 
-  return { sessions, upsert, remove, clear, get };
+  return useMemo(
+    () => ({ sessions, upsert, remove, clear, get }),
+    [sessions, upsert, remove, clear, get],
+  );
 }

package/dist/dashboard-runtime/dashboard/src/hooks/use-create-kb.ts

@@ -1,6 +1,7 @@
 import { useMutation, useQueryClient } from "@tanstack/react-query";
 import { createKnowledgeBase } from "@/services/knowledge-base";
 import type { CreateKBRequest } from "@/types/knowledge-base";
+import { invalidateKnowledgeBaseQueries } from "@/lib/query-keys";
 
 export function useCreateKB() {
   const queryClient = useQueryClient();
@@ -8,7 +9,7 @@ export function useCreateKB() {
   return useMutation({
     mutationFn: (request: CreateKBRequest) => createKnowledgeBase(request),
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["knowledge-bases"] });
+      invalidateKnowledgeBaseQueries(queryClient);
     },
   });
 }

package/dist/dashboard-runtime/dashboard/src/hooks/use-create-llm-provider.ts

@@ -2,15 +2,14 @@ import { useMutation, useQueryClient } from "@tanstack/react-query";
 
 import { createProvider } from "@/services/llm-providers";
 import type { CreateLLMProviderInput } from "@/types/llm-provider";
-
-import { LLM_PROVIDERS_QUERY_KEY } from "./use-llm-providers";
+import { invalidateLLMProviderQueries } from "@/lib/query-keys";
 
 export function useCreateLLMProvider() {
   const queryClient = useQueryClient();
   return useMutation({
     mutationFn: (input: CreateLLMProviderInput) => createProvider(input),
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: LLM_PROVIDERS_QUERY_KEY });
+      invalidateLLMProviderQueries(queryClient);
     },
   });
 }

package/dist/dashboard-runtime/dashboard/src/hooks/use-create-memory-store.ts

@@ -1,6 +1,7 @@
 import { useMutation, useQueryClient } from "@tanstack/react-query";
 import { createMemoryStore } from "@/services/memory";
 import type { CreateMemoryStoreRequest } from "@/types/memory";
+import { invalidateMemoryQueries } from "@/lib/query-keys";
 
 export function useCreateMemoryStore() {
   const queryClient = useQueryClient();
@@ -8,7 +9,7 @@ export function useCreateMemoryStore() {
   return useMutation({
     mutationFn: (request: CreateMemoryStoreRequest) => createMemoryStore(request),
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["memory", "stores"] });
+      invalidateMemoryQueries(queryClient);
     },
   });
 }

package/dist/dashboard-runtime/dashboard/src/hooks/use-delete-documents.ts

@@ -1,16 +1,21 @@
 import { useMutation, useQueryClient } from "@tanstack/react-query";
 import { deleteDocuments } from "@/services/documents";
 import type { DeleteDocumentsRequest } from "@/services/documents";
+import { invalidateKnowledgeBaseQueries } from "@/lib/query-keys";
+
+interface DeleteDocumentsVariables {
+  request: DeleteDocumentsRequest;
+  onProgress?: (completed: number, total: number) => void;
+}
 
 export function useDeleteDocuments() {
   const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: (request: DeleteDocumentsRequest) => deleteDocuments(request),
-    onSuccess: (_data, variables) => {
-      queryClient.invalidateQueries({
-        queryKey: ["knowledge-bases", variables.knowledgeBaseName, "documents"],
-      });
+    mutationFn: ({ request, onProgress }: DeleteDocumentsVariables) =>
+      deleteDocuments(request, onProgress),
+    onSuccess: () => {
+      invalidateKnowledgeBaseQueries(queryClient);
     },
   });
 }

package/dist/dashboard-runtime/dashboard/src/hooks/use-delete-kb.ts

@@ -1,5 +1,6 @@
 import { useMutation, useQueryClient } from "@tanstack/react-query";
 import { deleteKnowledgeBase } from "@/services/knowledge-base";
+import { invalidateKnowledgeBaseQueries } from "@/lib/query-keys";
 
 export function useDeleteKB() {
   const queryClient = useQueryClient();
@@ -7,7 +8,7 @@ export function useDeleteKB() {
   return useMutation({
     mutationFn: (name: string) => deleteKnowledgeBase(name),
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["knowledge-bases"] });
+      invalidateKnowledgeBaseQueries(queryClient);
     },
   });
 }

package/dist/dashboard-runtime/dashboard/src/hooks/use-delete-llm-provider.ts

@@ -1,15 +1,14 @@
 import { useMutation, useQueryClient } from "@tanstack/react-query";
 
 import { deleteProvider } from "@/services/llm-providers";
-
-import { LLM_PROVIDERS_QUERY_KEY } from "./use-llm-providers";
+import { invalidateLLMProviderQueries } from "@/lib/query-keys";
 
 export function useDeleteLLMProvider() {
   const queryClient = useQueryClient();
   return useMutation({
     mutationFn: (id: string) => deleteProvider(id),
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: LLM_PROVIDERS_QUERY_KEY });
+      invalidateLLMProviderQueries(queryClient);
     },
   });
 }

package/dist/dashboard-runtime/dashboard/src/hooks/use-delete-memory-store.ts

@@ -1,5 +1,6 @@
 import { useMutation, useQueryClient } from "@tanstack/react-query";
 import { deleteMemoryStore } from "@/services/memory";
+import { invalidateMemoryQueries } from "@/lib/query-keys";
 
 export function useDeleteMemoryStore() {
   const queryClient = useQueryClient();
@@ -7,7 +8,7 @@ export function useDeleteMemoryStore() {
   return useMutation({
     mutationFn: (memoryStoreName: string) => deleteMemoryStore(memoryStoreName),
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["memory", "stores"] });
+      invalidateMemoryQueries(queryClient);
     },
   });
 }

package/dist/dashboard-runtime/dashboard/src/hooks/use-delete-memory-unit.ts

@@ -1,15 +1,15 @@
 import { useMutation, useQueryClient } from "@tanstack/react-query";
 import { deleteMemoryUnit } from "@/services/memory";
 import type { DeleteMemoryUnitRequest } from "@/types/memory";
+import { invalidateMemoryQueries } from "@/lib/query-keys";
 
 export function useDeleteMemoryUnit() {
   const queryClient = useQueryClient();
 
   return useMutation({
     mutationFn: (request: DeleteMemoryUnitRequest) => deleteMemoryUnit(request),
-    onSuccess: (_data, variables) => {
-      queryClient.invalidateQueries({ queryKey: ["memory", "stores", variables.memoryStoreName, "units"] });
-      queryClient.invalidateQueries({ queryKey: ["memory", "stores", variables.memoryStoreName, "requests"] });
+    onSuccess: () => {
+      invalidateMemoryQueries(queryClient);
     },
   });
 }

package/dist/dashboard-runtime/dashboard/src/hooks/use-documents.ts

@@ -1,5 +1,7 @@
 import { useQuery } from "@tanstack/react-query";
 import { listDocuments } from "@/services/documents";
+import { queryKeys } from "@/lib/query-keys";
+import { useRuntimeContext } from "@/providers/runtime-context-provider";
 
 export function useDocuments(
   knowledgeBaseName: string,
@@ -10,18 +12,18 @@ export function useDocuments(
     enabled?: boolean;
   },
 ) {
+  const { context, ready } = useRuntimeContext();
   const { nextToken, maxResults = 20, subspace, enabled = true } = options ?? {};
   return useQuery({
-    queryKey: [
-      "knowledge-bases",
+    queryKey: queryKeys.documents(
+      context.dataScopeKey,
       knowledgeBaseName,
-      "documents",
       nextToken,
       maxResults,
       subspace,
-    ],
+    ),
     queryFn: () => listDocuments(knowledgeBaseName, { maxResults, nextToken, subspace }),
-    enabled: !!knowledgeBaseName && enabled,
+    enabled: ready && !!knowledgeBaseName && enabled,
     staleTime: 30_000,
   });
 }