@tablestore/tablestore-agent-cli 0.4.0 → 0.4.1

package/dist/dashboard-runtime/dashboard/src/app/(dashboard)/memory/[store]/units/page.tsx

@@ -13,6 +13,13 @@ import {
 import { toast } from "sonner";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
 import { PageHeader } from "@/components/layout/page-header";
 import { ConfirmDialog } from "@/components/shared/confirm-dialog";
 import { RefreshButton } from "@/components/shared/refresh-button";
@@ -26,7 +33,11 @@ import {
 import { useMemoryUnits } from "@/hooks/use-memory-units";
 import { useDeleteMemoryUnit } from "@/hooks/use-delete-memory-unit";
 import { useMemoryStore } from "@/hooks/use-memory-store";
-import { buildMemoryScope, hasWildcardScope } from "@/lib/memory";
+import {
+  buildMemoryScope,
+  hasPreciseScope,
+  hasWildcardScope,
+} from "@/lib/memory";
 import { storageModeCapabilities } from "@/lib/memory-storage-mode";
 import {
   applyFileScopeToSearchParams,
@@ -49,6 +60,10 @@ import { FileScopeOnboarding } from "@/components/memory/file-scope-onboarding";
 import { apiGet } from "@/services/api-client";
 import { useI18n } from "@/i18n/i18n-context";
 import { useDataScopeKey } from "@/providers/runtime-context-provider";
+import {
+  shouldRefreshUnitsAfterAdd,
+  type MemoryUnitsViewMode,
+} from "@/lib/memory-units-view";
 
 export default function MemoryUnitsPage() {
   const { t } = useI18n();
@@ -75,7 +90,7 @@ export default function MemoryUnitsPage() {
   const writableFileMemory = capabilities.writableFiles;
   const requestedView = searchParams.get("view");
   const requestedFile = searchParams.get("file");
-  const [viewMode, setViewMode] = useState<"units" | "files">(
+  const [viewMode, setViewMode] = useState<MemoryUnitsViewMode>(
     requestedView === "files" ? "files" : "units",
   );
   useEffect(() => {
@@ -144,7 +159,7 @@ export default function MemoryUnitsPage() {
     tokenStack: string[];
     currentToken?: string;
   }>({ scopeKey, tokenStack: [] });
-  const [pageSize] = useState(20);
+  const [pageSize, setPageSize] = useState(20);
   const [searchId, setSearchId] = useState("");
   const [searchedUnit, setSearchedUnit] = useState<MemoryUnit | null>(null);
   const [searching, setSearching] = useState(false);
@@ -247,8 +262,8 @@ export default function MemoryUnitsPage() {
       toast.error(t("memory.units.searchIdRequired"));
       return;
     }
-    if (!scope.appId) {
-      toast.error(t("memory.units.preciseScopeRequired"));
+    if (!hasPreciseScope(scope)) {
+      toast.error(t("memory.units.idSearchPreciseScopeRequired"));
       return;
     }
     setSearching(true);
@@ -309,41 +324,41 @@ export default function MemoryUnitsPage() {
           {fileMemory && capabilities.structured && (
             <UnitsViewToggle viewMode={viewMode} onChange={setViewMode} t={t} />
           )}
-          {viewMode === "units" && (
-            <>
-              <RefreshButton
-                loading={unitsQuery.isRefetching}
-                onClick={() => {
-                  unitsQuery.refetch();
-                  clearSearch();
-                }}
-              />
-              {wildcard ? (
-                <TooltipProvider delayDuration={200}>
-                  <Tooltip>
-                    <TooltipTrigger asChild>
-                      <span tabIndex={0} className="inline-flex">
-                        <Button disabled className="pointer-events-none">
-                          <Plus className="mr-2 h-4 w-4" />
-                          {t("memory.units.addMemory")}
-                        </Button>
-                      </span>
-                    </TooltipTrigger>
-                    <TooltipContent side="bottom" className="max-w-[240px]">
-                      <p>{t("memory.units.addWildcardHint")}</p>
-                    </TooltipContent>
-                  </Tooltip>
-                </TooltipProvider>
-              ) : (
-                <Button
-                  onClick={() => setAddDialogState({ scopeKey, open: true })}
-                >
-                  <Plus className="mr-2 h-4 w-4" />
-                  {t("memory.units.addMemory")}
-                </Button>
-              )}
-            </>
-          )}
+          {viewMode === "units" ? (
+            <RefreshButton
+              loading={unitsQuery.isRefetching}
+              onClick={() => {
+                unitsQuery.refetch();
+                clearSearch();
+              }}
+            />
+          ) : null}
+          {capabilities.acceptsMessages ? (
+            wildcard ? (
+              <TooltipProvider delayDuration={200}>
+                <Tooltip>
+                  <TooltipTrigger asChild>
+                    <span tabIndex={0} className="inline-flex">
+                      <Button disabled className="pointer-events-none">
+                        <Plus className="mr-2 h-4 w-4" />
+                        {t("memory.units.addMemory")}
+                      </Button>
+                    </span>
+                  </TooltipTrigger>
+                  <TooltipContent side="bottom" className="max-w-[240px]">
+                    <p>{t("memory.units.addWildcardHint")}</p>
+                  </TooltipContent>
+                </Tooltip>
+              </TooltipProvider>
+            ) : (
+              <Button
+                onClick={() => setAddDialogState({ scopeKey, open: true })}
+              >
+                <Plus className="mr-2 h-4 w-4" />
+                {t("memory.units.addMemory")}
+              </Button>
+            )
+          ) : null}
         </div>
       </PageHeader>
 
@@ -378,7 +393,7 @@ export default function MemoryUnitsPage() {
             />
             <Button
               onClick={handleSearchById}
-              disabled={searching || !scope.appId}
+              disabled={searching || !hasPreciseScope(scope)}
             >
               <Search className="mr-1.5 h-4 w-4" />
               {searching ? t("memory.units.querying") : t("memory.units.query")}
@@ -408,11 +423,35 @@ export default function MemoryUnitsPage() {
           />
 
           {!searchedUnit && (
-            <div className="flex items-center justify-between py-2">
+            <div className="flex flex-wrap items-center justify-between gap-3 py-2">
               <span className="text-sm text-muted-foreground">
-                {t("memory.units.page", { page: tokenStack.length + 1 })}
+                {t("memory.units.pagination", {
+                  page: tokenStack.length + 1,
+                  total: unitsQuery.data?.totalCount ?? units.length,
+                })}
               </span>
-              <div className="flex items-center gap-4">
+              <div className="flex items-center gap-3">
+                <Select
+                  value={String(pageSize)}
+                  onValueChange={(value) => {
+                    setPageSize(Number(value));
+                    setPagination({ scopeKey, tokenStack: [] });
+                  }}
+                >
+                  <SelectTrigger
+                    className="h-8 w-[112px]"
+                    aria-label={t("memory.units.pageSize")}
+                  >
+                    <SelectValue />
+                  </SelectTrigger>
+                  <SelectContent>
+                    {[10, 20, 50].map((size) => (
+                      <SelectItem key={size} value={String(size)}>
+                        {t("memory.units.pageSizeValue", { size })}
+                      </SelectItem>
+                    ))}
+                  </SelectContent>
+                </Select>
                 <Button
                   variant="outline"
                   size="sm"
@@ -465,11 +504,14 @@ export default function MemoryUnitsPage() {
       <MemoryAddDialog
         memoryStoreName={memoryStoreName}
         scope={scope}
+        projectsToFiles={capabilities.files}
         open={showAddDialog}
         onOpenChange={(open) => setAddDialogState({ scopeKey, open })}
         onSuccess={() => {
-          unitsQuery.refetch();
           clearSearch();
+          if (shouldRefreshUnitsAfterAdd(viewMode)) {
+            void unitsQuery.refetch();
+          }
         }}
       />
       <MemoryUnitDetailPanel
@@ -512,8 +554,8 @@ function UnitsViewToggle({
   onChange,
   t,
 }: {
-  viewMode: "units" | "files";
-  onChange: (mode: "units" | "files") => void;
+  viewMode: MemoryUnitsViewMode;
+  onChange: (mode: MemoryUnitsViewMode) => void;
   t: ReturnType<typeof useI18n>["t"];
 }) {
   const options: Array<{

package/dist/dashboard-runtime/dashboard/src/app/api/v1/llm/chat/memory-retrieval.ts

@@ -5,7 +5,7 @@ import type {
   ChatStreamEvent,
   RetrievalFailure,
 } from "@/types/llm-chat";
-import type { MemorySearchHit } from "@/types/memory";
+import type { MemoryFileSearchHit, MemorySearchHit } from "@/types/memory";
 import { normalizeFileMemoryStoreName } from "@/lib/file-memory-core";
 import { formatFileMemoryBlock } from "./file-memory-helpers";
 import { loadServerFileMemory } from "./server-file-memory";
@@ -31,6 +31,54 @@ const FILE_MEMORY_CACHE_UNAVAILABLE: RetrievalFailure = {
   message: "File memory cache is unavailable",
 };
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function isMemorySearchHit(value: unknown): value is MemorySearchHit {
+  return (
+    isRecord(value) &&
+    isRecord(value.unit) &&
+    typeof value.unit.text === "string"
+  );
+}
+
+function isMemoryFileSearchHit(value: unknown): value is MemoryFileSearchHit {
+  return (
+    isRecord(value) &&
+    typeof value.itemId === "string" &&
+    value.itemId.length > 0 &&
+    typeof value.path === "string" &&
+    value.path.length > 0 &&
+    (value.summary === undefined || typeof value.summary === "string")
+  );
+}
+
+function memoryHitRank(hit: MemorySearchHit): number {
+  for (const value of [hit.rankingScore, hit.score, hit.similarity]) {
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+  }
+  return Number.NEGATIVE_INFINITY;
+}
+
+/** Merge the server's per-output buckets into one bounded Chat context. */
+export function mergeMemorySearchHits(
+  structuredHits: MemorySearchHit[],
+  managedFileHits: MemorySearchHit[],
+  topK: number,
+): MemorySearchHit[] {
+  return [...structuredHits, ...managedFileHits]
+    .map((hit, index) => ({ hit, index }))
+    .sort((left, right) => {
+      const leftRank = memoryHitRank(left.hit);
+      const rightRank = memoryHitRank(right.hit);
+      if (leftRank !== rightRank) return rightRank > leftRank ? 1 : -1;
+      return left.index - right.index;
+    })
+    .slice(0, topK)
+    .map(({ hit }) => hit);
+}
+
 function isAbortError(error: unknown): boolean {
   return (
     error !== null &&
@@ -110,6 +158,7 @@ export async function retrieveMemoryContext({
   }
 
   try {
+    const topK = binding.topK ?? 5;
     const response = await waitWithSignal(
       Promise.resolve(
         client.searchMemories(
@@ -117,7 +166,7 @@ export async function retrieveMemoryContext({
             memoryStoreName: binding.memoryStoreName,
             scope: deriveReadScope(binding.scope as MemoryWriteScope),
             query,
-            topK: binding.topK ?? 5,
+            topK,
           },
           signal,
         ),
@@ -137,8 +186,27 @@ export async function retrieveMemoryContext({
     }
 
     // The SDK wire field is `results`, not the historic dashboard-only `hits`.
-    const data = response.data as { results?: MemorySearchHit[] } | undefined;
-    const hits = data?.results ?? [];
+    const data = isRecord(response.data) ? response.data : {};
+    const structuredHits = Array.isArray(data.results)
+      ? data.results.filter(isMemorySearchHit)
+      : [];
+    const fileResults = Array.isArray(data.fileResults)
+      ? data.fileResults.filter(isMemoryFileSearchHit)
+      : [];
+    const managedFileHits = fileResults.map<MemorySearchHit>((hit) => ({
+      unit: {
+        memoryId: hit.itemId,
+        text: hit.summary || hit.path,
+        metadata: {
+          path: hit.path,
+          ...(hit.versionId ? { versionId: hit.versionId } : {}),
+        },
+      },
+      score: hit.score,
+      similarity: hit.similarity,
+      source: `managed-file:${hit.path}`,
+    }));
+    const hits = mergeMemorySearchHits(structuredHits, managedFileHits, topK);
     return {
       query,
       hits,

package/dist/dashboard-runtime/dashboard/src/app/api/v1/memory/stores/[store]/route.ts

@@ -1,10 +1,12 @@
 import { type NextRequest } from "next/server";
+import type { StandardResponse } from "@tablestore/tablestore-agent-sdk";
 
 import {
   forwardResponse,
   handleApiError,
   requireClients,
 } from "@/lib/server/api-helpers";
+import { normalizeMemoryStoreContract } from "@/lib/server/memory-store-contract";
 
 export const runtime = "nodejs";
 export const dynamic = "force-dynamic";
@@ -19,6 +21,21 @@ interface RouteContext {
   params: Promise<{ store: string }>;
 }
 
+function forwardNormalizedStoreResponse(resp: StandardResponse) {
+  if (
+    resp.code === "SUCCESS" &&
+    resp.data &&
+    typeof resp.data === "object" &&
+    !Array.isArray(resp.data)
+  ) {
+    return forwardResponse({
+      ...resp,
+      data: normalizeMemoryStoreContract(resp.data as Record<string, unknown>),
+    });
+  }
+  return forwardResponse(resp);
+}
+
 export async function GET(request: NextRequest, context: RouteContext) {
   try {
     const { store } = await context.params;
@@ -27,7 +44,7 @@ export async function GET(request: NextRequest, context: RouteContext) {
     const { memory } = auth;
 
     const resp = await memory.getMemoryStore({ memoryStoreName: store });
-    return forwardResponse(resp);
+    return forwardNormalizedStoreResponse(resp);
   } catch (error) {
     return handleApiError(error);
   }
@@ -57,7 +74,7 @@ export async function PUT(request: NextRequest, context: RouteContext) {
       ...safeBody,
       memoryStoreName: store,
     });
-    return forwardResponse(resp);
+    return forwardNormalizedStoreResponse(resp);
   } catch (error) {
     return handleApiError(error);
   }

package/dist/dashboard-runtime/dashboard/src/app/api/v1/memory/stores/[store]/scopes/route.ts

@@ -9,6 +9,7 @@ import {
   requireClients,
   successResponse,
 } from "@/lib/server/api-helpers";
+import { parseScopeDirectoryFilter } from "@/lib/server/scope-filter-validation";
 
 import { readPaginationFromQuery, readScopeFromQuery } from "../_scope";
 
@@ -23,6 +24,88 @@ interface RouteContext {
   params: Promise<{ store: string }>;
 }
 
+const SCOPE_FIELDS = ["appId", "tenantId", "agentId", "runId"] as const;
+const MAX_SCOPE_DIRECTORY_LIMIT = 100;
+
+function badRequest(message: string) {
+  return forwardResponse({ code: "BAD_REQUEST", data: null, message });
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function buildScopeDirectoryRequest(
+  body: Record<string, unknown>,
+): { request: Record<string, unknown> } | { error: string } {
+  const safeBody: Record<string, unknown> = {};
+
+  if (body.scope !== undefined && body.scope !== null) {
+    if (!isRecord(body.scope)) {
+      return { error: "scope must be a JSON object" };
+    }
+    for (const field of Object.keys(body.scope)) {
+      if (!SCOPE_FIELDS.includes(field as (typeof SCOPE_FIELDS)[number])) {
+        return { error: `Unknown scope field: ${field}` };
+      }
+    }
+    const scope: Record<string, string> = {};
+    for (const field of SCOPE_FIELDS) {
+      const value = body.scope[field];
+      if (value === undefined) continue;
+      if (typeof value !== "string" || value.trim() === "") {
+        return { error: `scope.${field} must be a non-empty string` };
+      }
+      scope[field] = value;
+    }
+    if (Object.keys(scope).length > 0) safeBody.scope = scope;
+  }
+
+  if (body.filter !== undefined && body.filter !== null) {
+    const parsedFilter = parseScopeDirectoryFilter(body.filter);
+    if ("error" in parsedFilter) return { error: parsedFilter.error };
+    safeBody.filter = parsedFilter.filter;
+  }
+
+  if (body.limit !== undefined) {
+    if (
+      typeof body.limit !== "number" ||
+      !Number.isInteger(body.limit) ||
+      body.limit <= 0 ||
+      body.limit > MAX_SCOPE_DIRECTORY_LIMIT
+    ) {
+      return {
+        error: `limit must be an integer between 1 and ${MAX_SCOPE_DIRECTORY_LIMIT}`,
+      };
+    }
+    safeBody.limit = body.limit;
+  }
+
+  if (body.nextToken !== undefined) {
+    if (typeof body.nextToken !== "string") {
+      return { error: "nextToken must be a string" };
+    }
+    if (body.nextToken) safeBody.nextToken = body.nextToken;
+  }
+
+  return { request: safeBody };
+}
+
+function normalizedScopeResponse(
+  data: Record<string, unknown>,
+  store: string,
+  fallbackScope?: unknown,
+) {
+  const items = Array.isArray(data.scopes) ? data.scopes : [];
+  return successResponse({
+    items,
+    totalCount: items.length,
+    nextToken: typeof data.nextToken === "string" ? data.nextToken : undefined,
+    scope: data.scope ?? fallbackScope ?? {},
+    memoryStoreName: store,
+  });
+}
+
 export async function GET(request: NextRequest, context: RouteContext) {
   try {
     const { store } = await context.params;
@@ -49,16 +132,48 @@ export async function GET(request: NextRequest, context: RouteContext) {
     // shape so the dashboard frontend's paginated list helpers can
     // consume scopes/tasks/dream-tasks/actions through one unified
     // contract instead of branching on per-route field names.
-    const data = (response.data ?? {}) as Record<string, unknown>;
-    const items = Array.isArray(data.scopes) ? data.scopes : [];
-    return successResponse({
-      items,
-      totalCount: items.length,
-      nextToken:
-        typeof data.nextToken === "string" ? data.nextToken : undefined,
-      scope: data.scope ?? scope,
+    return normalizedScopeResponse(
+      (response.data ?? {}) as Record<string, unknown>,
+      store,
+      scope,
+    );
+  } catch (error) {
+    return handleApiError(error);
+  }
+}
+
+/**
+ * POST keeps the structured Filter AST and opaque nextToken in the request
+ * body.  The legacy GET route remains for ScopeBar compatibility.
+ */
+export async function POST(request: NextRequest, context: RouteContext) {
+  try {
+    const { store } = await context.params;
+    const auth = requireClients(request);
+    if (!("memory" in auth)) return auth;
+
+    let rawBody: unknown;
+    try {
+      rawBody = await request.json();
+    } catch {
+      return badRequest("Request body must be JSON");
+    }
+    if (!isRecord(rawBody)) {
+      return badRequest("Request body must be a JSON object");
+    }
+    const parsedBody = buildScopeDirectoryRequest(rawBody);
+    if ("error" in parsedBody) return badRequest(parsedBody.error);
+    const safeBody = parsedBody.request;
+    const response = await auth.memory.listMemoryStoreScopes({
+      ...safeBody,
       memoryStoreName: store,
     });
+    if (response.code !== "SUCCESS") return forwardResponse(response);
+    return normalizedScopeResponse(
+      (response.data ?? {}) as Record<string, unknown>,
+      store,
+      safeBody.scope,
+    );
   } catch (error) {
     return handleApiError(error);
   }

package/dist/dashboard-runtime/dashboard/src/app/api/v1/memory/stores/[store]/search/route.ts

@@ -5,6 +5,7 @@ import {
   handleApiError,
   requireClients,
 } from "@/lib/server/api-helpers";
+import { parseScopeDirectoryFilter } from "@/lib/server/scope-filter-validation";
 
 export const runtime = "nodejs";
 export const dynamic = "force-dynamic";
@@ -17,6 +18,14 @@ interface RouteContext {
   params: Promise<{ store: string }>;
 }
 
+function badRequest(message: string) {
+  return forwardResponse({ code: "BAD_REQUEST", data: null, message });
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
 export async function POST(request: NextRequest, context: RouteContext) {
   try {
     const { store } = await context.params;
@@ -24,20 +33,24 @@ export async function POST(request: NextRequest, context: RouteContext) {
     if (!("memory" in auth)) return auth;
     const { memory } = auth;
 
-    let body: Record<string, unknown>;
+    let rawBody: unknown;
     try {
-      body = (await request.json()) as Record<string, unknown>;
+      rawBody = await request.json();
     } catch {
-      return forwardResponse({
-        code: "BAD_REQUEST",
-        data: null,
-        message: "Request body must be JSON",
-      });
+      return badRequest("Request body must be JSON");
     }
+    if (!isRecord(rawBody)) return badRequest("Request body must be an object");
 
     // Strip client-supplied memoryStoreName so the URL-derived value wins (D2).
-    const { memoryStoreName: _ignored, ...safeBody } = body;
+    const { memoryStoreName: _ignored, ...safeBody } = rawBody;
     void _ignored;
+    if (safeBody.filter === null) {
+      delete safeBody.filter;
+    } else if (safeBody.filter !== undefined) {
+      const parsedFilter = parseScopeDirectoryFilter(safeBody.filter);
+      if ("error" in parsedFilter) return badRequest(parsedFilter.error);
+      safeBody.filter = parsedFilter.filter;
+    }
     const resp = await memory.searchMemories({
       ...safeBody,
       memoryStoreName: store,

package/dist/dashboard-runtime/dashboard/src/app/api/v1/memory/stores/route.ts

@@ -10,6 +10,7 @@ import {
   successResponse,
 } from "@/lib/server/api-helpers";
 import { paginateAll } from "@tablestore/tablestore-agent-sdk";
+import { normalizeMemoryStoreContract } from "@/lib/server/memory-store-contract";
 
 /**
  * GET  /api/v1/memory/stores   List all memory stores (auto-paginated).
@@ -36,18 +37,24 @@ export async function GET(request: NextRequest) {
           const resp = await memory.getMemoryStore({
             memoryStoreName: item.memoryStoreName,
           });
-          if (resp.code !== "SUCCESS") return item;
+          if (resp.code !== "SUCCESS") {
+            return normalizeMemoryStoreContract(item);
+          }
           const data = (resp.data ?? {}) as {
             storageMode?: string;
             description?: string;
+            inputType?: string;
+            outputTypes?: string[];
           };
-          return {
+          return normalizeMemoryStoreContract({
             ...item,
             ...(data.storageMode ? { storageMode: data.storageMode } : {}),
             ...(data.description ? { description: data.description } : {}),
-          };
+            ...(data.inputType ? { inputType: data.inputType } : {}),
+            ...(data.outputTypes ? { outputTypes: data.outputTypes } : {}),
+          });
         } catch {
-          return item;
+          return normalizeMemoryStoreContract(item);
         }
       }),
     );

package/dist/dashboard-runtime/dashboard/src/components/chat/chat-config-context.tsx

@@ -19,6 +19,7 @@ import { assembleRetrievalConfiguration } from "@/components/retrieval/assemble-
 import { newId } from "@/lib/random-id";
 import {
   FILEMEM_DEFAULT_RUN_ID,
+  isKnownStorageMode,
   normalizeMemoryRunId,
   type StorageMode,
 } from "@/lib/memory-storage-mode";
@@ -162,11 +163,7 @@ function isExactMemoryBinding(memory: ChatMemoryBinding | undefined): boolean {
 function hasExplicitKnownStorageMode(
   memory: ChatMemoryBinding | undefined,
 ): boolean {
-  return (
-    memory?.storageMode === "ots" ||
-    memory?.storageMode === "file+ots" ||
-    memory?.storageMode === "filemem"
-  );
+  return isKnownStorageMode(memory?.storageMode);
 }
 
 export function isWikiEligibleMemoryBinding(

package/dist/dashboard-runtime/dashboard/src/components/chat/wiki-bind-section.tsx

@@ -14,6 +14,7 @@ import { Label } from "@/components/ui/label";
 import { Switch } from "@/components/ui/switch";
 import { useWiki } from "@/hooks/use-wikis";
 import { useI18n } from "@/i18n/i18n-context";
+import { isKnownStorageMode } from "@/lib/memory-storage-mode";
 import type { Wiki } from "@/types/wiki";
 
 function isExactScope(
@@ -39,10 +40,7 @@ export function WikiBindSection() {
   const { t } = useI18n();
   const cfg = useChatConfig();
   const binding = cfg.memory;
-  const knownStorageMode =
-    binding?.storageMode === "ots" ||
-    binding?.storageMode === "file+ots" ||
-    binding?.storageMode === "filemem";
+  const knownStorageMode = isKnownStorageMode(binding?.storageMode);
   const exactScope = isExactScope(binding?.scope) ? binding.scope : undefined;
   const eligibleScope = isWikiEligibleMemoryBinding(binding)
     ? exactScope