@tablestore/tablestore-agent-cli 0.2.10 → 0.2.11

package/dist/dashboard-runtime/dashboard/src/components/memory/memory-create-form.tsx

@@ -6,7 +6,13 @@ import { useForm } from "react-hook-form";
 import { zodResolver } from "@hookform/resolvers/zod";
 import { z } from "zod";
 import { toast } from "sonner";
-import { Brain, Database, FolderTree, Sparkles } from "lucide-react";
+import {
+  Brain,
+  Database,
+  FilePenLine,
+  FolderTree,
+  Sparkles,
+} from "lucide-react";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
 import { Textarea } from "@/components/ui/textarea";
@@ -23,39 +29,69 @@ import { useCreateMemoryStore } from "@/hooks/use-create-memory-store";
 import { useLocaleRevalidation } from "@/hooks/use-locale-revalidation";
 import { cn } from "@/lib/utils";
 import {
-  storageModeDescription,
-  storageModeLabel,
-  type StorageMode,
+  memoryStorageSelectionForInput,
+  storageSelectionToMode,
+  toggleMemoryFileStorage,
 } from "@/lib/memory-storage-mode";
 import { useI18n } from "@/i18n/i18n-context";
 import type { TranslateFn } from "@/i18n/i18n-context";
+import type { CreateMemoryStoreRequest } from "@/types/memory";
 
 function buildCreateMemoryStoreSchema(t: TranslateFn) {
-  return z.object({
-    memoryStoreName: z
-      .string()
-      .trim()
-      .min(1, t("memory.create.nameRequired"))
-      .max(32, t("memory.create.nameMaxLength"))
-      .regex(/^[a-zA-Z0-9_]+$/, t("memory.create.namePattern")),
-    description: z
-      .string()
-      .trim()
-      .max(256, t("memory.create.descriptionMaxLength"))
-      .optional(),
-    storageMode: z.enum(["ots", "oss+ots"]),
-    extractInstructions: z
-      .string()
-      .trim()
-      .max(4096, t("memory.create.extractMaxLength"))
-      .optional(),
-  });
+  return z
+    .object({
+      memoryStoreName: z
+        .string()
+        .trim()
+        .min(1, t("memory.create.nameRequired"))
+        .max(32, t("memory.create.nameMaxLength"))
+        .regex(/^[a-zA-Z0-9_]+$/, t("memory.create.namePattern")),
+      description: z
+        .string()
+        .trim()
+        .max(256, t("memory.create.descriptionMaxLength"))
+        .optional(),
+      inputType: z.enum(["short-term", "file"]),
+      storageStructures: z
+        .array(z.enum(["structured", "file"]))
+        .min(1, t("memory.create.storageStructureRequired")),
+      extractInstructions: z
+        .string()
+        .trim()
+        .max(4096, t("memory.create.extractMaxLength"))
+        .optional(),
+    })
+    .superRefine((values, context) => {
+      try {
+        storageSelectionToMode(values);
+      } catch {
+        context.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["storageStructures"],
+          message: t("memory.create.storageStructureInvalid"),
+        });
+      }
+    });
 }
 
 type CreateMemoryStoreInput = z.infer<
   ReturnType<typeof buildCreateMemoryStoreSchema>
 >;
 
+export function buildCreateMemoryStoreRequest(
+  values: CreateMemoryStoreInput,
+): CreateMemoryStoreRequest {
+  const storageMode = storageSelectionToMode(values);
+  const extractInstructions = values.extractInstructions?.trim();
+  return {
+    memoryStoreName: values.memoryStoreName,
+    description: values.description?.length ? values.description : undefined,
+    storageMode,
+    extractInstructions:
+      storageMode === "filemem" ? undefined : extractInstructions || undefined,
+  };
+}
+
 export function MemoryCreateForm() {
   const router = useRouter();
   const createStore = useCreateMemoryStore();
@@ -71,25 +107,18 @@ export function MemoryCreateForm() {
     defaultValues: {
       memoryStoreName: "",
       description: "",
-      storageMode: "ots",
+      inputType: "short-term",
+      storageStructures: ["structured"],
       extractInstructions: "",
     },
   });
 
   useLocaleRevalidation(form);
+  const selectedInputType = form.watch("inputType");
 
   async function onSubmit(values: CreateMemoryStoreInput) {
     try {
-      await createStore.mutateAsync({
-        memoryStoreName: values.memoryStoreName,
-        description: values.description?.length
-          ? values.description
-          : undefined,
-        storageMode: values.storageMode,
-        extractInstructions: values.extractInstructions?.length
-          ? values.extractInstructions
-          : undefined,
-      });
+      await createStore.mutateAsync(buildCreateMemoryStoreRequest(values));
       toast.success(t("memory.list.createSuccess"));
       router.push("/memory");
     } catch (error) {
@@ -159,29 +188,47 @@ export function MemoryCreateForm() {
 
         <section className="rounded-lg border border-[hsl(var(--border))] bg-[hsl(var(--card))] p-5 shadow-sm">
           <FormSectionHeader
-            title={t("memory.create.storageModeSection")}
-            description={t("memory.create.storageModeSectionDesc")}
+            title={t("memory.create.inputTypeSection")}
+            description={t("memory.create.inputTypeSectionDesc")}
           />
           <FormField
             control={form.control}
-            name="storageMode"
+            name="inputType"
             render={({ field }) => (
               <FormItem>
                 <FormControl>
-                  <div className="grid gap-3 sm:grid-cols-2">
-                    <StorageModeOption
-                      value="ots"
+                  <div className="grid gap-3 md:grid-cols-2">
+                    <SelectionOption
                       icon={<Database className="h-5 w-5" />}
-                      selected={field.value === "ots"}
-                      onSelect={() => field.onChange("ots")}
-                      t={t}
+                      label={t("memory.create.shortTermInputLabel")}
+                      description={t("memory.create.shortTermInputDescription")}
+                      selected={field.value === "short-term"}
+                      onSelect={() => {
+                        const selection =
+                          memoryStorageSelectionForInput("short-term");
+                        field.onChange(selection.inputType);
+                        form.setValue(
+                          "storageStructures",
+                          selection.storageStructures,
+                          { shouldDirty: true, shouldValidate: true },
+                        );
+                      }}
                     />
-                    <StorageModeOption
-                      value="oss+ots"
-                      icon={<FolderTree className="h-5 w-5" />}
-                      selected={field.value === "oss+ots"}
-                      onSelect={() => field.onChange("oss+ots")}
-                      t={t}
+                    <SelectionOption
+                      icon={<FilePenLine className="h-5 w-5" />}
+                      label={t("memory.create.fileInputLabel")}
+                      description={t("memory.create.fileInputDescription")}
+                      selected={field.value === "file"}
+                      onSelect={() => {
+                        const selection =
+                          memoryStorageSelectionForInput("file");
+                        field.onChange(selection.inputType);
+                        form.setValue(
+                          "storageStructures",
+                          selection.storageStructures,
+                          { shouldDirty: true, shouldValidate: true },
+                        );
+                      }}
                     />
                   </div>
                 </FormControl>
@@ -193,32 +240,78 @@ export function MemoryCreateForm() {
 
         <section className="rounded-lg border border-[hsl(var(--border))] bg-[hsl(var(--card))] p-5 shadow-sm">
           <FormSectionHeader
-            title={t("memory.create.extractSection")}
-            description={t("memory.create.extractSectionDesc")}
+            title={t("memory.create.storageStructureSection")}
+            description={t("memory.create.storageStructureSectionDesc")}
           />
           <FormField
             control={form.control}
-            name="extractInstructions"
+            name="storageStructures"
             render={({ field }) => (
               <FormItem>
-                <FormLabel>{t("memory.create.extractLabel")}</FormLabel>
                 <FormControl>
-                  <Textarea
-                    placeholder={t("memory.create.extractPlaceholder")}
-                    className="resize-none"
-                    rows={5}
-                    {...field}
-                  />
+                  <div className="grid gap-3 md:grid-cols-2">
+                    <SelectionOption
+                      icon={<Database className="h-5 w-5" />}
+                      label={t("memory.create.structuredStorageLabel")}
+                      description={t(
+                        "memory.create.structuredStorageDescription",
+                      )}
+                      selected={field.value.includes("structured")}
+                      disabled
+                      onSelect={() => undefined}
+                    />
+                    <SelectionOption
+                      icon={<FolderTree className="h-5 w-5" />}
+                      label={t("memory.create.fileStorageLabel")}
+                      description={t("memory.create.fileStorageDescription")}
+                      selected={field.value.includes("file")}
+                      disabled={selectedInputType === "file"}
+                      onSelect={() => {
+                        const selection = toggleMemoryFileStorage({
+                          inputType: selectedInputType,
+                          storageStructures: field.value,
+                        });
+                        field.onChange(selection.storageStructures);
+                      }}
+                    />
+                  </div>
                 </FormControl>
-                <FormDescription>
-                  {t("memory.create.extractHelp")}
-                </FormDescription>
                 <FormMessage />
               </FormItem>
             )}
           />
         </section>
 
+        {selectedInputType === "short-term" && (
+          <section className="rounded-lg border border-[hsl(var(--border))] bg-[hsl(var(--card))] p-5 shadow-sm">
+            <FormSectionHeader
+              title={t("memory.create.extractSection")}
+              description={t("memory.create.extractSectionDesc")}
+            />
+            <FormField
+              control={form.control}
+              name="extractInstructions"
+              render={({ field }) => (
+                <FormItem>
+                  <FormLabel>{t("memory.create.extractLabel")}</FormLabel>
+                  <FormControl>
+                    <Textarea
+                      placeholder={t("memory.create.extractPlaceholder")}
+                      className="resize-none"
+                      rows={5}
+                      {...field}
+                    />
+                  </FormControl>
+                  <FormDescription>
+                    {t("memory.create.extractHelp")}
+                  </FormDescription>
+                  <FormMessage />
+                </FormItem>
+              )}
+            />
+          </section>
+        )}
+
         <div className="flex justify-end gap-3 border-t border-[hsl(var(--border-light))] pt-4">
           <Button
             type="button"
@@ -281,33 +374,33 @@ function CreateMemoryHero() {
   );
 }
 
-/**
- * 存储模式选择卡片：仅 API 记忆（ots）/ 支持文件记忆（oss+ots）。文案取自
- * storageModeLabel/Description，保证与列表徽标、设置页说明一致。
- */
-function StorageModeOption({
-  value,
+function SelectionOption({
   icon,
+  label,
+  description,
   selected,
+  disabled = false,
   onSelect,
-  t,
 }: {
-  value: StorageMode;
   icon: React.ReactNode;
+  label: string;
+  description: string;
   selected: boolean;
+  disabled?: boolean;
   onSelect: () => void;
-  t: TranslateFn;
 }) {
   return (
     <button
       type="button"
       onClick={onSelect}
       aria-pressed={selected}
+      disabled={disabled}
       className={cn(
         "flex flex-col items-start gap-2 rounded-lg border p-4 text-left transition-colors",
         selected
           ? "border-[hsl(var(--primary)/0.5)] bg-[hsl(var(--primary-soft))] ring-1 ring-[hsl(var(--primary)/0.18)]"
           : "border-[hsl(var(--border))] hover:bg-[hsl(var(--muted)/0.4)]",
+        disabled && "cursor-default opacity-75",
       )}
     >
       <div className="flex items-center gap-2">
@@ -321,12 +414,10 @@ function StorageModeOption({
         >
           {icon}
         </span>
-        <span className="text-sm font-semibold text-foreground">
-          {storageModeLabel(value, t)}
-        </span>
+        <span className="text-sm font-semibold text-foreground">{label}</span>
       </div>
       <p className="text-xs leading-relaxed text-muted-foreground">
-        {storageModeDescription(value, t)}
+        {description}
       </p>
     </button>
   );

package/dist/dashboard-runtime/dashboard/src/components/memory/memory-dream-create-dialog.tsx

@@ -54,37 +54,161 @@ interface DreamCreateDialogProps {
   onOpenChange: (open: boolean) => void;
 }
 
-function buildFormSchema(t: TranslateFn) {
-  const scopeSchema = z
+interface DreamSchemaMessages {
+  appIdRequired: string;
+  atLeastOneNonWildcard: string;
+  atLeastOneScope: string;
+  scopesLimit: string;
+  instructionsLimit: string;
+  maxSessionsRange: string;
+  maxMessagesRange: string;
+  maxMemoriesRange: string;
+  thresholdRange: string;
+  timestampInvalid: string;
+  timestampOrder: string;
+}
+
+const DEFAULT_SCHEMA_MESSAGES: DreamSchemaMessages = {
+  appIdRequired: "appId 必填",
+  atLeastOneNonWildcard: "至少指定一个非通配符字段",
+  atLeastOneScope: "至少一个 scope",
+  scopesLimit: "scope 最多 20 个",
+  instructionsLimit: "指令不能超过 4000 字节（UTF-8）",
+  maxSessionsRange: "最大会话数必须是 1 到 100 之间的整数",
+  maxMessagesRange: "最大消息数必须是 1 到 20000 之间的整数",
+  maxMemoriesRange: "最大记忆数必须是 1 到 5000 之间的整数",
+  thresholdRange: "置信度阈值必须在 0 到 1 之间",
+  timestampInvalid: "时间格式不正确",
+  timestampOrder: "最晚时间不能早于最早时间",
+};
+
+function createDreamScopeSchema(messages: DreamSchemaMessages) {
+  return z
     .object({
-      appId: z.string().trim().min(1, t("memory.dream.appIdRequired")),
+      appId: z.string().trim().min(1, messages.appIdRequired),
       tenantId: z.string().trim().optional(),
       agentId: z.string().trim().optional(),
       runId: z.string().trim().optional(),
     })
     .refine((s) => Object.values(s).some((v) => v && v !== "*"), {
-      message: t("memory.dream.atLeastOneNonWildcard"),
+      message: messages.atLeastOneNonWildcard,
+      path: ["appId"],
     });
+}
 
-  return z.object({
-    taskType: z.enum(["memory", "skill", "profile"]),
-    scopes: z.array(scopeSchema).min(1, t("memory.dream.atLeastOneScope")),
-    applyMode: z.enum(["proposal", "safe_auto"]),
-    scopeOutputMode: z.enum(["preserve_scope", "promote_scope"]).optional(),
-    minTimestamp: z.string().optional(),
-    maxTimestamp: z.string().optional(),
-    maxSessions: z.string().optional(),
-    maxMessages: z.string().optional(),
-    maxMemories: z.string().optional(),
-    instructions: z.string().optional(),
-    clientToken: z.string().optional(),
-    thresholdAdd: z.string().optional(),
-    thresholdUpdate: z.string().optional(),
-    thresholdMerge: z.string().optional(),
+function optionalIntegerString(max: number, message: string) {
+  return z
+    .string()
+    .trim()
+    .optional()
+    .superRefine((value, ctx) => {
+      if (!value) return;
+      const parsed = Number(value);
+      if (!Number.isInteger(parsed) || parsed < 1 || parsed > max) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message });
+      }
+    });
+}
+
+function optionalThresholdString(message: string) {
+  return z
+    .string()
+    .trim()
+    .optional()
+    .superRefine((value, ctx) => {
+      if (!value) return;
+      const parsed = Number(value);
+      if (!Number.isFinite(parsed) || parsed < 0 || parsed > 1) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message });
+      }
+    });
+}
+
+function optionalTimestampString(message: string) {
+  return z
+    .string()
+    .trim()
+    .optional()
+    .superRefine((value, ctx) => {
+      if (value && !Number.isFinite(Date.parse(value))) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message });
+      }
+    });
+}
+
+function createDreamFormSchema(messages: DreamSchemaMessages) {
+  const scopeSchema = createDreamScopeSchema(messages);
+
+  return z
+    .object({
+      taskType: z.enum(["memory", "skill", "profile"]),
+      scopes: z
+        .array(scopeSchema)
+        .min(1, messages.atLeastOneScope)
+        .max(20, messages.scopesLimit),
+      applyMode: z.enum(["proposal", "safe_auto"]),
+      scopeOutputMode: z.enum(["preserve_scope", "promote_scope"]).optional(),
+      minTimestamp: optionalTimestampString(messages.timestampInvalid),
+      maxTimestamp: optionalTimestampString(messages.timestampInvalid),
+      maxSessions: optionalIntegerString(100, messages.maxSessionsRange),
+      maxMessages: optionalIntegerString(20_000, messages.maxMessagesRange),
+      maxMemories: optionalIntegerString(5_000, messages.maxMemoriesRange),
+      instructions: z
+        .string()
+        .optional()
+        .superRefine((value, ctx) => {
+          if (value && new TextEncoder().encode(value).byteLength > 4_000) {
+            ctx.addIssue({
+              code: z.ZodIssueCode.custom,
+              message: messages.instructionsLimit,
+            });
+          }
+        }),
+      clientToken: z.string().optional(),
+      thresholdAdd: optionalThresholdString(messages.thresholdRange),
+      thresholdUpdate: optionalThresholdString(messages.thresholdRange),
+      thresholdMerge: optionalThresholdString(messages.thresholdRange),
+    })
+    .superRefine((values, ctx) => {
+      if (!values.minTimestamp || !values.maxTimestamp) return;
+      const minTimestamp = Date.parse(values.minTimestamp);
+      const maxTimestamp = Date.parse(values.maxTimestamp);
+      if (
+        Number.isFinite(minTimestamp) &&
+        Number.isFinite(maxTimestamp) &&
+        maxTimestamp < minTimestamp
+      ) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: messages.timestampOrder,
+          path: ["maxTimestamp"],
+        });
+      }
+    });
+}
+
+export const dreamScopeSchema = createDreamScopeSchema(DEFAULT_SCHEMA_MESSAGES);
+export const dreamCreateFormSchema = createDreamFormSchema(
+  DEFAULT_SCHEMA_MESSAGES,
+);
+
+function buildFormSchema(t: TranslateFn) {
+  return createDreamFormSchema({
+    appIdRequired: t("memory.dream.appIdRequired"),
+    atLeastOneNonWildcard: t("memory.dream.atLeastOneNonWildcard"),
+    atLeastOneScope: t("memory.dream.atLeastOneScope"),
+    scopesLimit: t("memory.dream.scopesLimit"),
+    instructionsLimit: t("memory.dream.instructionsLimit"),
+    maxSessionsRange: t("memory.dream.maxSessionsRange"),
+    maxMessagesRange: t("memory.dream.maxMessagesRange"),
+    maxMemoriesRange: t("memory.dream.maxMemoriesRange"),
+    thresholdRange: t("memory.dream.thresholdRange"),
+    timestampInvalid: t("memory.dream.timestampInvalid"),
+    timestampOrder: t("memory.dream.timestampOrder"),
   });
 }
 
-type FormValues = z.infer<ReturnType<typeof buildFormSchema>>;
+type FormValues = z.infer<typeof dreamCreateFormSchema>;
 
 function parseOptionalInt(raw: string | undefined): number | undefined {
   if (!raw) return undefined;
@@ -428,6 +552,7 @@ function MemoryDreamCreateDialogInner({
                         {...field}
                       />
                     </FormControl>
+                    <FormMessage />
                   </FormItem>
                 );
               }}
@@ -611,6 +736,7 @@ function NumberField({
               value={typeof field.value === "string" ? field.value : ""}
             />
           </FormControl>
+          <FormMessage />
         </FormItem>
       )}
     />
@@ -641,6 +767,7 @@ function DatetimeField({
               value={typeof field.value === "string" ? field.value : ""}
             />
           </FormControl>
+          <FormMessage />
         </FormItem>
       )}
     />