@tablestore/tablestore-agent-cli 0.4.0 → 0.4.1

package/dist/dashboard-runtime/dashboard/src/lib/memory-storage-mode.ts

@@ -1,7 +1,12 @@
 import type { TranslateFn } from "@/i18n/i18n-context";
 import { newId } from "@/lib/random-id";
 
-export type StorageMode = "ots" | "file+ots" | "filemem";
+/**
+ * `managed-file` is a console capability label for the current
+ * messages -> [file] contract.  It is never sent as the legacy storageMode
+ * wire field.
+ */
+export type StorageMode = "ots" | "managed-file" | "file+ots" | "filemem";
 export type MemoryInputType = "short-term" | "file";
 export type MemoryStorageStructure = "structured" | "file";
 export type MemoryDetailSegment =
@@ -23,6 +28,17 @@ export interface MemoryStorageSelection {
   storageStructures: MemoryStorageStructure[];
 }
 
+export interface MemoryStoreTypeContract {
+  inputType: "messages" | "file";
+  outputTypes: MemoryStorageStructure[];
+}
+
+export interface MemoryStoreTypeSource {
+  inputType?: "messages" | "file";
+  outputTypes?: MemoryStorageStructure[];
+  storageMode?: string | null;
+}
+
 export const FILEMEM_DEFAULT_RUN_ID = "__default__";
 
 function createRandomRunId(): string {
@@ -38,11 +54,19 @@ export function normalizeMemoryRunId(
   return !runId || runId === FILEMEM_DEFAULT_RUN_ID ? createRunId() : runId;
 }
 
-export const STORAGE_MODE_VALUES: StorageMode[] = [
+export const STORAGE_MODE_VALUES = [
   "ots",
+  "managed-file",
   "file+ots",
   "filemem",
-];
+] as const satisfies readonly StorageMode[];
+
+export function isKnownStorageMode(value: unknown): value is StorageMode {
+  return (
+    typeof value === "string" &&
+    (STORAGE_MODE_VALUES as readonly string[]).includes(value)
+  );
+}
 
 const STRUCTURED_DETAIL_SEGMENTS: MemoryDetailSegment[] = [
   "scope",
@@ -56,7 +80,18 @@ const STRUCTURED_DETAIL_SEGMENTS: MemoryDetailSegment[] = [
   "settings",
 ];
 const FILE_DETAIL_SEGMENTS: MemoryDetailSegment[] = [
+  "scope",
+  "units",
+  "wiki",
+  "settings",
+];
+const MANAGED_FILE_DETAIL_SEGMENTS: MemoryDetailSegment[] = [
+  "scope",
   "units",
+  "search",
+  "messages",
+  "tasks",
+  "requests",
   "wiki",
   "settings",
 ];
@@ -67,7 +102,7 @@ const STRUCTURED_CARD_SHORTCUTS: MemoryCardShortcut[] = [
   "consolidate",
 ];
 const FILE_CARD_SHORTCUTS: MemoryCardShortcut[] = ["files"];
-const STRUCTURED_CARD_ACTIONS: MemoryCardAction[] = [
+const SEARCHABLE_CARD_ACTIONS: MemoryCardAction[] = [
   "units",
   "search",
   "settings",
@@ -84,6 +119,7 @@ export function parseKnownStorageMode(
   value: string | undefined | null,
 ): StorageMode | null {
   if (value === "ots") return "ots";
+  if (value === "managed-file") return "managed-file";
   if (value === "file+ots" || value === "oss+ots") return "file+ots";
   if (value === "filemem") return "filemem";
   return null;
@@ -111,6 +147,23 @@ export function toggleMemoryFileStorage(
       };
 }
 
+export function toggleMemoryStructuredStorage(
+  selection: MemoryStorageSelection,
+): MemoryStorageSelection {
+  if (selection.inputType === "file") {
+    return memoryStorageSelectionForInput("file");
+  }
+  if (selection.storageStructures.includes("structured")) {
+    return selection.storageStructures.includes("file")
+      ? { inputType: "short-term", storageStructures: ["file"] }
+      : selection;
+  }
+  return {
+    inputType: "short-term",
+    storageStructures: ["structured", "file"],
+  };
+}
+
 export function storageSelectionToMode(
   selection: MemoryStorageSelection,
 ): StorageMode {
@@ -128,19 +181,39 @@ export function storageSelectionToMode(
   if (
     !hasDuplicates &&
     selection.inputType === "short-term" &&
-    structures.has("structured")
+    structures.size > 0
   ) {
-    if (structures.size === 1) return "ots";
+    if (structures.size === 1 && structures.has("structured")) return "ots";
+    if (structures.size === 1 && structures.has("file")) return "managed-file";
     if (structures.size === 2 && structures.has("file")) return "file+ots";
   }
   throw new Error("Invalid memory input and storage structure combination");
 }
 
+/**
+ * Convert the console selection to the current server contract.  New stores
+ * must use inputType/outputTypes instead of the legacy storageMode alias so a
+ * messages -> file-only store is not collapsed into one of the old modes.
+ */
+export function storageSelectionToStoreType(
+  selection: MemoryStorageSelection,
+): MemoryStoreTypeContract {
+  // Reuse the strict combination validation above before translating labels.
+  storageSelectionToMode(selection);
+  return {
+    inputType: selection.inputType === "short-term" ? "messages" : "file",
+    outputTypes: [...selection.storageStructures],
+  };
+}
+
 export function storageModeToSelection(
   value: string | undefined | null,
 ): MemoryStorageSelection {
   const mode = normalizeStorageMode(value);
   if (mode === "filemem") return memoryStorageSelectionForInput("file");
+  if (mode === "managed-file") {
+    return { inputType: "short-term", storageStructures: ["file"] };
+  }
   if (mode === "file+ots") {
     return {
       inputType: "short-term",
@@ -150,25 +223,47 @@ export function storageModeToSelection(
   return memoryStorageSelectionForInput("short-term");
 }
 
+export function resolveMemoryStoreTypeContract(
+  store: MemoryStoreTypeSource,
+): MemoryStoreTypeContract {
+  const fallback = storageSelectionToStoreType(
+    storageModeToSelection(store.storageMode),
+  );
+  return {
+    inputType: store.inputType ?? fallback.inputType,
+    outputTypes:
+      store.outputTypes && store.outputTypes.length > 0
+        ? [...store.outputTypes]
+        : fallback.outputTypes,
+  };
+}
+
 export function storageModeCapabilities(value: string | undefined | null) {
   const mode = normalizeStorageMode(value);
-  const structured = mode !== "filemem";
+  const structured = mode === "ots" || mode === "file+ots";
+  const acceptsMessages = mode !== "filemem";
+  let detailSegments = FILE_DETAIL_SEGMENTS;
+  if (mode === "managed-file") {
+    detailSegments = MANAGED_FILE_DETAIL_SEGMENTS;
+  } else if (structured) {
+    detailSegments = STRUCTURED_DETAIL_SEGMENTS;
+  }
   return {
     mode,
-    files: mode !== "ots",
+    files: mode === "managed-file" || mode === "file+ots" || mode === "filemem",
     structured,
     writableFiles: mode === "filemem",
     forceLocalRetrieval: mode === "filemem",
     structuredAutoSave: structured,
     supportsExtraction: structured,
-    detailSegments: [
-      ...(structured ? STRUCTURED_DETAIL_SEGMENTS : FILE_DETAIL_SEGMENTS),
-    ],
+    acceptsMessages,
+    discoverableScopes: acceptsMessages,
+    detailSegments: [...detailSegments],
     cardShortcuts: [
       ...(structured ? STRUCTURED_CARD_SHORTCUTS : FILE_CARD_SHORTCUTS),
     ],
     cardActions: [
-      ...(structured ? STRUCTURED_CARD_ACTIONS : FILE_CARD_ACTIONS),
+      ...(mode === "filemem" ? FILE_CARD_ACTIONS : SEARCHABLE_CARD_ACTIONS),
     ],
   } as const;
 }
@@ -199,15 +294,19 @@ export function storageModeLabel(
 ): string {
   const mode = normalizeStorageMode(value);
   if (t) {
-    return t(
-      mode === "filemem"
-        ? "memory.storageMode.writableFileLabel"
-        : mode === "file+ots"
-          ? "memory.storageMode.projectedFileLabel"
-          : "memory.storageMode.apiOnlyLabel",
-    );
+    if (mode === "filemem") {
+      return t("memory.storageMode.writableFileLabel");
+    }
+    if (mode === "managed-file") {
+      return t("memory.storageMode.managedFileLabel");
+    }
+    if (mode === "file+ots") {
+      return t("memory.storageMode.projectedFileLabel");
+    }
+    return t("memory.storageMode.apiOnlyLabel");
   }
   if (mode === "filemem") return "Writable File Memory";
+  if (mode === "managed-file") return "Managed File Memory";
   if (mode === "file+ots") return "Read-only File Projection";
   return "API-only Memory";
 }
@@ -216,14 +315,16 @@ export function resolveRetrievalMode(
   mode: "search" | "local" | undefined,
   storageMode: string | boolean | undefined | null,
 ): "search" | "local" {
-  const resolvedStorage =
-    typeof storageMode === "boolean"
-      ? storageMode
-        ? "file+ots"
-        : "ots"
-      : normalizeStorageMode(storageMode);
+  let resolvedStorage: StorageMode;
+  if (typeof storageMode === "boolean") {
+    resolvedStorage = storageMode ? "file+ots" : "ots";
+  } else {
+    resolvedStorage = normalizeStorageMode(storageMode);
+  }
   if (resolvedStorage === "filemem") return "local";
-  if (resolvedStorage === "ots") return "search";
+  if (resolvedStorage === "ots" || resolvedStorage === "managed-file") {
+    return "search";
+  }
   return mode === "local" ? "local" : "search";
 }
 
@@ -233,17 +334,23 @@ export function storageModeDescription(
 ): string {
   const mode = normalizeStorageMode(value);
   if (t) {
-    return t(
-      mode === "filemem"
-        ? "memory.storageMode.writableFileDescription"
-        : mode === "file+ots"
-          ? "memory.storageMode.projectedFileDescription"
-          : "memory.storageMode.apiOnlyDescription",
-    );
+    if (mode === "filemem") {
+      return t("memory.storageMode.writableFileDescription");
+    }
+    if (mode === "managed-file") {
+      return t("memory.storageMode.managedFileDescription");
+    }
+    if (mode === "file+ots") {
+      return t("memory.storageMode.projectedFileDescription");
+    }
+    return t("memory.storageMode.apiOnlyDescription");
   }
   if (mode === "filemem") {
     return "Writable file memory with JSON API CRUD, version history, and local lexical retrieval.";
   }
+  if (mode === "managed-file") {
+    return "Short-term messages are consolidated into a managed, read-only file tree.";
+  }
   if (mode === "file+ots") {
     return "Read-only file projection browsed through the JSON file API.";
   }

package/dist/dashboard-runtime/dashboard/src/lib/memory-units-view.ts

@@ -0,0 +1,9 @@
+export type MemoryUnitsViewMode = "units" | "files";
+
+/** Adding a message only invalidates the structured list while that list is
+ * active. The files view disables its units query and must not refetch it. */
+export function shouldRefreshUnitsAfterAdd(
+  viewMode: MemoryUnitsViewMode,
+): boolean {
+  return viewMode === "units";
+}

package/dist/dashboard-runtime/dashboard/src/lib/memory.ts

@@ -27,14 +27,9 @@ export function hasPreciseScope(scope: MemoryScope): boolean {
   );
 }
 
-/** appId and tenantId are present and not `*` (minimum for search). */
+/** The current SearchMemories contract only requires an exact appId. */
 export function hasSearchableScope(scope: MemoryScope): boolean {
-  return (
-    !!scope.appId &&
-    scope.appId !== "*" &&
-    !!scope.tenantId &&
-    scope.tenantId !== "*"
-  );
+  return !!scope.appId && scope.appId !== "*";
 }
 
 export function scopeToSearchParams(scope: MemoryScope): URLSearchParams {

package/dist/dashboard-runtime/dashboard/src/lib/query-keys.ts

@@ -294,6 +294,19 @@ export const queryKeys = {
       nextToken,
       limit,
     ] as const,
+  memoryScopeDirectory: (
+    scopeKey: string,
+    memoryStoreName: string,
+    requestKey: string,
+  ) =>
+    [
+      "memory",
+      scopeKey,
+      "stores",
+      memoryStoreName,
+      "scope-directory",
+      requestKey,
+    ] as const,
   memoryTasks: (
     scopeKey: string,
     memoryStoreName: string,

package/dist/dashboard-runtime/dashboard/src/lib/scope-directory.ts

@@ -0,0 +1,97 @@
+import type {
+  MemoryScopeDirectoryEntry,
+  ScopeDirectoryFilter,
+} from "@/types/memory";
+import { buildScopeWorkspaceHref } from "@/lib/scope-workspace";
+
+export type ScopeDirectoryTypeFilter = "all" | "conversation" | "wiki";
+export type ScopeDirectoryMatchOp = "eq" | "prefix" | "wildcard";
+
+export interface ScopeDirectoryFilterInput {
+  scopeType: ScopeDirectoryTypeFilter;
+  field?: string;
+  op?: ScopeDirectoryMatchOp;
+  value?: string;
+}
+
+/** React state boundary for opaque pagination tokens. Tokens must never
+ * survive a Store or runtime data-scope transition. */
+export function buildScopeDirectoryStateKey(
+  dataScopeKey: string,
+  memoryStoreName: string,
+): string {
+  return JSON.stringify([dataScopeKey, memoryStoreName]);
+}
+
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === "string" && value.length > 0;
+}
+
+/** Only an exact four-part conversation Scope can open the point-lookup
+ * workspace. Directory entries with omitted dimensions remain browseable but
+ * must not be turned into a different Scope by filling synthetic sentinels. */
+export function buildScopeDirectoryWorkspaceHref(
+  memoryStoreName: string,
+  entry: MemoryScopeDirectoryEntry,
+): string | null {
+  if (
+    entry.scopeType !== "conversation" ||
+    !isNonEmptyString(entry.appId) ||
+    !isNonEmptyString(entry.tenantId) ||
+    !isNonEmptyString(entry.agentId) ||
+    !isNonEmptyString(entry.runId)
+  ) {
+    return null;
+  }
+  return buildScopeWorkspaceHref(memoryStoreName, {
+    appId: entry.appId,
+    tenantId: entry.tenantId,
+    agentId: entry.agentId,
+    runId: entry.runId,
+  });
+}
+
+/** Build the small visual filter form into the server's full Filter AST. */
+export function buildScopeDirectoryFilter(
+  input: ScopeDirectoryFilterInput,
+): ScopeDirectoryFilter {
+  const conditions: ScopeDirectoryFilter[] = [];
+  if (input.scopeType !== "all") {
+    conditions.push({
+      op: "eq",
+      field: "scopeType",
+      value: input.scopeType,
+    });
+  }
+  const field = input.field?.trim();
+  const value = input.value?.trim();
+  if (field && value) {
+    conditions.push({
+      op: input.op ?? "eq",
+      field,
+      value,
+    });
+  }
+  // A filter-only query is how callers request the whole heterogeneous
+  // directory. Omitting both scope and filter would mean the legacy default
+  // conversation scope instead.
+  if (conditions.length === 0) {
+    return { op: "exists", field: "scopeType" };
+  }
+  return conditions.length === 1 ? conditions[0] : { op: "and", conditions };
+}
+
+/** Legacy stores may reject a Filter AST with a generic 400. Scope-only
+ * requests must never be classified this way because they sent no Filter. */
+export function isScopeDirectoryUnsupported(
+  error: unknown,
+  usedFilter: boolean,
+): boolean {
+  if (!usedFilter || !(error instanceof Error)) return false;
+  const code =
+    "code" in error && typeof error.code === "string" ? error.code : "";
+  return (
+    code === "INVALID_PARAMETER" ||
+    error.message.toLowerCase().includes("invalid parameter")
+  );
+}

package/dist/dashboard-runtime/dashboard/src/lib/server/memory-store-contract.ts

@@ -0,0 +1,41 @@
+import {
+  parseKnownStorageMode,
+  type StorageMode,
+} from "@/lib/memory-storage-mode";
+
+type MemoryStoreWire = Record<string, unknown> & {
+  storageMode?: unknown;
+  inputType?: unknown;
+  outputTypes?: unknown;
+};
+
+/**
+ * The current service omits storageMode for stores created with the new
+ * inputType/outputTypes contract.  Keep one derived legacy label at the BFF
+ * boundary so the existing capability matrix remains correct while the UI
+ * also exposes the authoritative fields.
+ */
+export function normalizeMemoryStoreContract<T extends MemoryStoreWire>(
+  store: T,
+): T & { storageMode: StorageMode } {
+  const knownStorageMode =
+    typeof store.storageMode === "string"
+      ? parseKnownStorageMode(store.storageMode)
+      : null;
+  if (knownStorageMode) {
+    return { ...store, storageMode: knownStorageMode };
+  }
+
+  const outputs = new Set(
+    Array.isArray(store.outputTypes) ? store.outputTypes : [],
+  );
+  let storageMode: StorageMode = "ots";
+  if (store.inputType === "file") {
+    storageMode = "filemem";
+  } else if (outputs.has("file") && outputs.has("structured")) {
+    storageMode = "file+ots";
+  } else if (outputs.has("file")) {
+    storageMode = "managed-file";
+  }
+  return { ...store, storageMode };
+}

package/dist/dashboard-runtime/dashboard/src/lib/server/scope-filter-validation.ts

@@ -0,0 +1,186 @@
+import type { ScopeDirectoryFilter } from "@/types/memory";
+
+const FILTER_FIELD_PATTERN = /^[A-Za-z][A-Za-z0-9_]{0,63}$/;
+const MAX_FILTER_DEPTH = 8;
+const MAX_FILTER_LEAVES = 64;
+
+type FilterParseResult = { filter: ScopeDirectoryFilter } | { error: string };
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function hasOnlyKeys(
+  value: Record<string, unknown>,
+  allowed: readonly string[],
+): boolean {
+  return Object.keys(value).every((key) => allowed.includes(key));
+}
+
+function parseField(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const field = value.trim();
+  return FILTER_FIELD_PATTERN.test(field) ? field : null;
+}
+
+function parseFilterNode(
+  value: unknown,
+  depth: number,
+  counter: { leaves: number },
+): FilterParseResult {
+  if (depth >= MAX_FILTER_DEPTH) {
+    return { error: `filter exceeds maximum depth ${MAX_FILTER_DEPTH}` };
+  }
+  if (!isRecord(value) || typeof value.op !== "string") {
+    return { error: "filter nodes must be objects with a string op" };
+  }
+
+  const op = value.op.trim().toLowerCase();
+  const field = parseField(value.field);
+  if (["eq", "prefix", "wildcard"].includes(op)) {
+    if (!hasOnlyKeys(value, ["op", "field", "value"])) {
+      return { error: `filter ${op} contains unknown fields` };
+    }
+    if (!field || typeof value.value !== "string") {
+      return { error: `filter ${op} requires a valid field and string value` };
+    }
+    // Keep operand constraints aligned with scopedirectory.Filter.Validate in
+    // the service. It intentionally caps wildcard patterns only; imposing
+    // invented limits on eq/prefix/range/in here would reject valid requests.
+    if (op === "wildcard" && [...value.value].length > 32) {
+      return { error: "filter wildcard value exceeds 32 characters" };
+    }
+    counter.leaves += 1;
+    if (counter.leaves > MAX_FILTER_LEAVES) {
+      return {
+        error: `filter exceeds maximum leaf count ${MAX_FILTER_LEAVES}`,
+      };
+    }
+    return {
+      filter: {
+        op: op as "eq" | "prefix" | "wildcard",
+        field,
+        value: value.value,
+      },
+    };
+  }
+
+  if (op === "in") {
+    if (!hasOnlyKeys(value, ["op", "field", "values"])) {
+      return { error: "filter in contains unknown fields" };
+    }
+    if (
+      !field ||
+      !Array.isArray(value.values) ||
+      value.values.length === 0 ||
+      value.values.some((item) => typeof item !== "string")
+    ) {
+      return { error: "filter in requires a valid field and string values" };
+    }
+    counter.leaves += 1;
+    if (counter.leaves > MAX_FILTER_LEAVES) {
+      return {
+        error: `filter exceeds maximum leaf count ${MAX_FILTER_LEAVES}`,
+      };
+    }
+    return { filter: { op: "in", field, values: value.values as string[] } };
+  }
+
+  if (op === "range") {
+    if (!hasOnlyKeys(value, ["op", "field", "gt", "gte", "lt", "lte"])) {
+      return { error: "filter range contains unknown fields" };
+    }
+    const bounds = ["gt", "gte", "lt", "lte"] as const;
+    const presentBounds = bounds.filter((key) => value[key] !== undefined);
+    if (
+      !field ||
+      presentBounds.length === 0 ||
+      presentBounds.some((key) => typeof value[key] !== "string")
+    ) {
+      return {
+        error:
+          "filter range requires a valid field and at least one string bound",
+      };
+    }
+    if (
+      (value.gt !== undefined && value.gte !== undefined) ||
+      (value.lt !== undefined && value.lte !== undefined)
+    ) {
+      return { error: "filter range cannot combine gt/gte or lt/lte" };
+    }
+    counter.leaves += 1;
+    if (counter.leaves > MAX_FILTER_LEAVES) {
+      return {
+        error: `filter exceeds maximum leaf count ${MAX_FILTER_LEAVES}`,
+      };
+    }
+    return {
+      filter: {
+        op: "range",
+        field,
+        ...(typeof value.gt === "string" ? { gt: value.gt } : {}),
+        ...(typeof value.gte === "string" ? { gte: value.gte } : {}),
+        ...(typeof value.lt === "string" ? { lt: value.lt } : {}),
+        ...(typeof value.lte === "string" ? { lte: value.lte } : {}),
+      },
+    };
+  }
+
+  if (op === "exists") {
+    if (!hasOnlyKeys(value, ["op", "field"]) || !field) {
+      return { error: "filter exists requires exactly one known field" };
+    }
+    counter.leaves += 1;
+    if (counter.leaves > MAX_FILTER_LEAVES) {
+      return {
+        error: `filter exceeds maximum leaf count ${MAX_FILTER_LEAVES}`,
+      };
+    }
+    return { filter: { op: "exists", field } };
+  }
+
+  if (op === "and" || op === "or") {
+    if (!hasOnlyKeys(value, ["op", "conditions"])) {
+      return { error: `filter ${op} contains unknown fields` };
+    }
+    if (!Array.isArray(value.conditions) || value.conditions.length === 0) {
+      return { error: `filter ${op} requires non-empty conditions` };
+    }
+    const conditions: ScopeDirectoryFilter[] = [];
+    for (const condition of value.conditions) {
+      const parsed = parseFilterNode(condition, depth + 1, counter);
+      if ("error" in parsed) return parsed;
+      conditions.push(parsed.filter);
+    }
+    return { filter: { op, conditions } };
+  }
+
+  if (op === "not") {
+    if (!hasOnlyKeys(value, ["op", "condition", "conditions"])) {
+      return { error: "filter not contains unknown fields" };
+    }
+    const legacyConditions = Array.isArray(value.conditions)
+      ? value.conditions
+      : [];
+    if (
+      (value.condition !== undefined && legacyConditions.length !== 0) ||
+      (value.condition === undefined && legacyConditions.length !== 1)
+    ) {
+      return { error: "filter not requires exactly one condition" };
+    }
+    const parsed = parseFilterNode(
+      value.condition ?? legacyConditions[0],
+      depth + 1,
+      counter,
+    );
+    return "error" in parsed
+      ? parsed
+      : { filter: { op: "not", condition: parsed.filter } };
+  }
+
+  return { error: `unsupported filter op: ${op}` };
+}
+
+export function parseScopeDirectoryFilter(value: unknown): FilterParseResult {
+  return parseFilterNode(value, 0, { leaves: 0 });
+}

package/dist/dashboard-runtime/dashboard/src/schemas/llm-chat.ts

@@ -1,7 +1,10 @@
 import { z } from "zod";
 
 import { normalizeFileMemoryStoreName } from "@/lib/file-memory-core";
-import { FILEMEM_DEFAULT_RUN_ID } from "@/lib/memory-storage-mode";
+import {
+  FILEMEM_DEFAULT_RUN_ID,
+  STORAGE_MODE_VALUES,
+} from "@/lib/memory-storage-mode";
 
 export const chatRoleSchema = z.enum(["user", "assistant", "system"]);
 
@@ -67,7 +70,7 @@ const browserFileContextSchema = z.object({
 const chatMemoryWireSchema = z
   .object({
     memoryStoreName: z.string().min(1),
-    storageMode: z.enum(["ots", "file+ots", "filemem"]).optional(),
+    storageMode: z.enum(STORAGE_MODE_VALUES).optional(),
     scope: z.object({
       appId: nonWildcardId,
       tenantId: nonWildcardId,