@tablestore/tablestore-agent-cli 0.2.10 → 0.3.1

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

@@ -9,6 +9,7 @@ import { toast } from "sonner";
 import { Plus, Trash2 } from "lucide-react";
 
 import { Button } from "@/components/ui/button";
+import { Checkbox } from "@/components/ui/checkbox";
 import {
   Dialog,
   DialogContent,
@@ -44,7 +45,11 @@ import { useCreateDreamTask } from "@/hooks/use-create-dream-task";
 import { ScopeCombobox } from "@/components/memory/scope-combobox";
 import { useI18n } from "@/i18n/i18n-context";
 import type { TranslateFn } from "@/i18n/i18n-context";
-import type { DreamTaskType, MemoryScope } from "@/types/memory";
+import type {
+  CreateDreamTaskRequest,
+  DreamTaskType,
+  MemoryScope,
+} from "@/types/memory";
 
 interface DreamCreateDialogProps {
   memoryStoreName: string;
@@ -54,42 +59,238 @@ interface DreamCreateDialogProps {
   onOpenChange: (open: boolean) => void;
 }
 
-function buildFormSchema(t: TranslateFn) {
-  const scopeSchema = z
+interface DreamSchemaMessages {
+  appIdRequired: string;
+  atLeastOneNonWildcard: string;
+  atLeastOneScope: string;
+  scopesLimit: string;
+  agenticScopesLimit: string;
+  executionModeCombination: string;
+  taskTypeExecutionMode: string;
+  instructionsLimit: string;
+  maxSessionsRange: string;
+  maxMessagesRange: string;
+  maxMemoriesRange: string;
+  expandedScopeLimitRange: string;
+  thresholdRange: string;
+  timestampInvalid: string;
+  timestampOrder: string;
+}
+
+const DEFAULT_SCHEMA_MESSAGES: DreamSchemaMessages = {
+  appIdRequired: "appId 必填",
+  atLeastOneNonWildcard: "至少指定一个非通配符字段",
+  atLeastOneScope: "至少一个 scope",
+  scopesLimit: "scope 最多 20 个",
+  agenticScopesLimit: "Agentic Dream scope 最多 8 个",
+  executionModeCombination: "执行模式与应用模式组合无效",
+  taskTypeExecutionMode: "技能与画像任务不支持 multi_loop",
+  instructionsLimit: "指令不能超过 4000 字节（UTF-8）",
+  maxSessionsRange: "最大会话数必须是 0 到 100 之间的整数",
+  maxMessagesRange: "最大消息数必须是 0 到 20000 之间的整数",
+  maxMemoriesRange: "最大记忆数必须是 0 到 5000 之间的整数",
+  expandedScopeLimitRange: "展开 scope 上限必须是 0 到 1000 之间的整数",
+  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 < 0 || 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"]),
+      executionMode: z.enum(["single_loop", "multi_loop"]),
+      scopes: z
+        .array(scopeSchema)
+        .min(1, messages.atLeastOneScope)
+        .max(20, messages.scopesLimit),
+      applyMode: z.enum(["proposal", "safe_auto", "plan"]).optional(),
+      incremental: z.boolean().optional(),
+      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),
+      expandedScopeLimit: optionalIntegerString(
+        1_000,
+        messages.expandedScopeLimitRange,
+      ),
+      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) {
+        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"],
+          });
+        }
+      }
+
+      if (values.taskType !== "memory") {
+        if (values.executionMode === "multi_loop") {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: messages.taskTypeExecutionMode,
+            path: ["executionMode"],
+          });
+        }
+        if (values.applyMode !== undefined) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: messages.executionModeCombination,
+            path: ["applyMode"],
+          });
+        }
+        return;
+      }
+
+      if (values.applyMode === undefined) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: messages.executionModeCombination,
+          path: ["applyMode"],
+        });
+      } else if (
+        values.executionMode === "single_loop" &&
+        values.applyMode === "plan"
+      ) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: messages.executionModeCombination,
+          path: ["applyMode"],
+        });
+      } else if (
+        values.executionMode === "multi_loop" &&
+        values.applyMode === "proposal"
+      ) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: messages.executionModeCombination,
+          path: ["applyMode"],
+        });
+      }
+
+      if (values.executionMode === "multi_loop" && values.scopes.length > 8) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: messages.agenticScopesLimit,
+          path: ["scopes"],
+        });
+      }
+    });
+}
+
+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"),
+    agenticScopesLimit: t("memory.dream.agenticScopesLimit"),
+    executionModeCombination: t("memory.dream.executionModeCombination"),
+    taskTypeExecutionMode: t("memory.dream.taskTypeExecutionMode"),
+    instructionsLimit: t("memory.dream.instructionsLimit"),
+    maxSessionsRange: t("memory.dream.maxSessionsRange"),
+    maxMessagesRange: t("memory.dream.maxMessagesRange"),
+    maxMemoriesRange: t("memory.dream.maxMemoriesRange"),
+    expandedScopeLimitRange: t("memory.dream.expandedScopeLimitRange"),
+    thresholdRange: t("memory.dream.thresholdRange"),
+    timestampInvalid: t("memory.dream.timestampInvalid"),
+    timestampOrder: t("memory.dream.timestampOrder"),
   });
 }
 
-type FormValues = z.infer<ReturnType<typeof buildFormSchema>>;
+export type DreamCreateFormValues = z.infer<typeof dreamCreateFormSchema>;
+type FormValues = DreamCreateFormValues;
 
 function parseOptionalInt(raw: string | undefined): number | undefined {
-  if (!raw) return undefined;
+  if (raw === undefined || raw.trim() === "") return undefined;
   const n = Number(raw);
-  if (!Number.isFinite(n) || !Number.isInteger(n) || n <= 0) return undefined;
+  if (!Number.isFinite(n) || !Number.isInteger(n) || n < 0) return undefined;
   return n;
 }
 
@@ -100,6 +301,61 @@ function parseOptionalThreshold(raw: string | undefined): number | undefined {
   return n;
 }
 
+export function buildDreamCreateRequest(
+  values: DreamCreateFormValues,
+): CreateDreamTaskRequest {
+  const thresholds: Record<string, number> = {};
+  const thresholdAdd = parseOptionalThreshold(values.thresholdAdd);
+  const thresholdUpdate = parseOptionalThreshold(values.thresholdUpdate);
+  const thresholdMerge = parseOptionalThreshold(values.thresholdMerge);
+  if (thresholdAdd !== undefined) thresholds.add = thresholdAdd;
+  if (thresholdUpdate !== undefined) thresholds.update = thresholdUpdate;
+  if (thresholdMerge !== undefined) thresholds.merge = thresholdMerge;
+
+  const isMemory = values.taskType === "memory";
+  return {
+    scopes: values.scopes.map((scope) => {
+      const result: MemoryScope = { appId: scope.appId };
+      if (scope.tenantId) result.tenantId = scope.tenantId;
+      if (scope.agentId) result.agentId = scope.agentId;
+      if (scope.runId) result.runId = scope.runId;
+      return result;
+    }),
+    taskType: values.taskType,
+    executionMode: values.executionMode,
+    incremental: Boolean(values.incremental),
+    ...(isMemory && values.applyMode && { applyMode: values.applyMode }),
+    ...(isMemory &&
+      values.scopeOutputMode && {
+        scopeOutputMode: values.scopeOutputMode,
+      }),
+    ...(values.minTimestamp && {
+      minTimestamp: Date.parse(values.minTimestamp),
+    }),
+    ...(values.maxTimestamp && {
+      maxTimestamp: Date.parse(values.maxTimestamp),
+    }),
+    ...(parseOptionalInt(values.maxSessions) !== undefined && {
+      maxSessions: parseOptionalInt(values.maxSessions),
+    }),
+    ...(parseOptionalInt(values.maxMessages) !== undefined && {
+      maxMessages: parseOptionalInt(values.maxMessages),
+    }),
+    ...(parseOptionalInt(values.maxMemories) !== undefined && {
+      maxMemories: parseOptionalInt(values.maxMemories),
+    }),
+    ...(parseOptionalInt(values.expandedScopeLimit) !== undefined && {
+      expandedScopeLimit: parseOptionalInt(values.expandedScopeLimit),
+    }),
+    ...(values.instructions && { instructions: values.instructions }),
+    ...(values.clientToken && { clientToken: values.clientToken }),
+    ...(isMemory &&
+      Object.keys(thresholds).length > 0 && {
+        confidenceThresholds: thresholds,
+      }),
+  };
+}
+
 export function MemoryDreamCreateDialog(props: DreamCreateDialogProps) {
   const { locale } = useI18n();
   return <MemoryDreamCreateDialogInner key={locale} {...props} />;
@@ -141,7 +397,9 @@ function MemoryDreamCreateDialogInner({
               : "",
         },
       ],
+      executionMode: "single_loop",
       applyMode: "proposal",
+      incremental: false,
     },
   });
 
@@ -157,49 +415,10 @@ function MemoryDreamCreateDialogInner({
   const [thresholdsOpen, setThresholdsOpen] = useState(false);
 
   const onSubmit = async (values: FormValues) => {
-    const thresholds: Record<string, number> = {};
-    const tAdd = parseOptionalThreshold(values.thresholdAdd);
-    const tUpdate = parseOptionalThreshold(values.thresholdUpdate);
-    const tMerge = parseOptionalThreshold(values.thresholdMerge);
-    if (tAdd !== undefined) thresholds.add = tAdd;
-    if (tUpdate !== undefined) thresholds.update = tUpdate;
-    if (tMerge !== undefined) thresholds.merge = tMerge;
-
-    const isMemory = values.taskType === "memory";
-
     try {
-      const result = await createMutation.mutateAsync({
-        scopes: values.scopes.map((s) => {
-          const out: MemoryScope = { appId: s.appId };
-          if (s.tenantId) out.tenantId = s.tenantId;
-          if (s.agentId) out.agentId = s.agentId;
-          if (s.runId) out.runId = s.runId;
-          return out;
-        }),
-        taskType: values.taskType,
-        ...(isMemory && { applyMode: values.applyMode }),
-        ...(isMemory &&
-          values.scopeOutputMode && {
-            scopeOutputMode: values.scopeOutputMode,
-          }),
-        ...(values.minTimestamp && { minTimestamp: values.minTimestamp }),
-        ...(values.maxTimestamp && { maxTimestamp: values.maxTimestamp }),
-        ...(parseOptionalInt(values.maxSessions) !== undefined && {
-          maxSessions: parseOptionalInt(values.maxSessions),
-        }),
-        ...(parseOptionalInt(values.maxMessages) !== undefined && {
-          maxMessages: parseOptionalInt(values.maxMessages),
-        }),
-        ...(parseOptionalInt(values.maxMemories) !== undefined && {
-          maxMemories: parseOptionalInt(values.maxMemories),
-        }),
-        ...(values.instructions && { instructions: values.instructions }),
-        ...(values.clientToken && { clientToken: values.clientToken }),
-        ...(isMemory &&
-          Object.keys(thresholds).length > 0 && {
-            confidenceThresholds: thresholds,
-          }),
-      });
+      const result = await createMutation.mutateAsync(
+        buildDreamCreateRequest(values),
+      );
 
       const TOAST_MSG: Record<DreamTaskType, string> = {
         memory: t("memory.dream.toastMemoryCreated"),
@@ -238,8 +457,16 @@ function MemoryDreamCreateDialogInner({
                 <FormItem>
                   <FormLabel>{t("memory.dream.taskType")}</FormLabel>
                   <Select
-                    onValueChange={field.onChange}
-                    defaultValue={field.value}
+                    onValueChange={(value) => {
+                      field.onChange(value);
+                      if (value === "memory") {
+                        form.setValue("applyMode", "proposal");
+                      } else {
+                        form.setValue("executionMode", "single_loop");
+                        form.setValue("applyMode", undefined);
+                      }
+                    }}
+                    value={field.value}
                   >
                     <FormControl>
                       <SelectTrigger>
@@ -344,8 +571,50 @@ function MemoryDreamCreateDialogInner({
               </div>
             </section>
 
-            {isMemoryType && (
-              <section className="grid gap-3 sm:grid-cols-2">
+            <section className="grid gap-3 sm:grid-cols-3">
+              <FormField
+                control={form.control}
+                name="executionMode"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>{t("memory.dream.executionMode")}</FormLabel>
+                    <Select
+                      onValueChange={(value) => {
+                        field.onChange(value);
+                        const applyMode = form.getValues("applyMode");
+                        if (
+                          value === "multi_loop" &&
+                          applyMode === "proposal"
+                        ) {
+                          form.setValue("applyMode", "safe_auto");
+                        }
+                        if (value === "single_loop" && applyMode === "plan") {
+                          form.setValue("applyMode", "proposal");
+                        }
+                      }}
+                      value={field.value}
+                    >
+                      <FormControl>
+                        <SelectTrigger>
+                          <SelectValue />
+                        </SelectTrigger>
+                      </FormControl>
+                      <SelectContent>
+                        <SelectItem value="single_loop">
+                          {t("memory.dream.executionModeSingle")}
+                        </SelectItem>
+                        {isMemoryType && (
+                          <SelectItem value="multi_loop">
+                            {t("memory.dream.executionModeMulti")}
+                          </SelectItem>
+                        )}
+                      </SelectContent>
+                    </Select>
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+              {isMemoryType && (
                 <FormField
                   control={form.control}
                   name="applyMode"
@@ -353,8 +622,18 @@ function MemoryDreamCreateDialogInner({
                     <FormItem>
                       <FormLabel>{t("memory.dream.applyMode")}</FormLabel>
                       <Select
-                        onValueChange={field.onChange}
-                        defaultValue={field.value}
+                        onValueChange={(value) => {
+                          field.onChange(value);
+                          if (value === "plan") {
+                            form.setValue("executionMode", "multi_loop");
+                          } else if (
+                            value === "proposal" &&
+                            form.getValues("executionMode") === "multi_loop"
+                          ) {
+                            form.setValue("executionMode", "single_loop");
+                          }
+                        }}
+                        value={field.value ?? "proposal"}
                       >
                         <FormControl>
                           <SelectTrigger>
@@ -368,12 +647,17 @@ function MemoryDreamCreateDialogInner({
                           <SelectItem value="safe_auto">
                             {t("memory.dream.applyModeSafeAutoOption")}
                           </SelectItem>
+                          <SelectItem value="plan">
+                            {t("memory.dream.applyModePlanOption")}
+                          </SelectItem>
                         </SelectContent>
                       </Select>
                       <FormMessage />
                     </FormItem>
                   )}
                 />
+              )}
+              {isMemoryType && (
                 <FormField
                   control={form.control}
                   name="scopeOutputMode"
@@ -406,8 +690,8 @@ function MemoryDreamCreateDialogInner({
                     </FormItem>
                   )}
                 />
-              </section>
-            )}
+              )}
+            </section>
 
             <FormField
               control={form.control}
@@ -428,6 +712,7 @@ function MemoryDreamCreateDialogInner({
                         {...field}
                       />
                     </FormControl>
+                    <FormMessage />
                   </FormItem>
                 );
               }}
@@ -498,6 +783,11 @@ function MemoryDreamCreateDialogInner({
                   label={t("memory.dream.maxMemories")}
                   form={form}
                 />
+                <NumberField
+                  name="expandedScopeLimit"
+                  label={t("memory.dream.expandedScopeLimit")}
+                  form={form}
+                />
                 <DatetimeField
                   name="minTimestamp"
                   label={t("memory.dream.minTimestamp")}
@@ -523,6 +813,26 @@ function MemoryDreamCreateDialogInner({
                     </FormItem>
                   )}
                 />
+                <FormField
+                  control={form.control}
+                  name="incremental"
+                  render={({ field }) => (
+                    <FormItem className="flex items-center gap-2 pt-5">
+                      <FormControl>
+                        <Checkbox
+                          checked={Boolean(field.value)}
+                          onCheckedChange={(checked) =>
+                            field.onChange(checked === true)
+                          }
+                        />
+                      </FormControl>
+                      <FormLabel className="text-xs">
+                        {t("memory.dream.incremental")}
+                      </FormLabel>
+                      <FormMessage />
+                    </FormItem>
+                  )}
+                />
               </CollapsibleContent>
             </Collapsible>
 
@@ -611,6 +921,7 @@ function NumberField({
               value={typeof field.value === "string" ? field.value : ""}
             />
           </FormControl>
+          <FormMessage />
         </FormItem>
       )}
     />
@@ -641,6 +952,7 @@ function DatetimeField({
               value={typeof field.value === "string" ? field.value : ""}
             />
           </FormControl>
+          <FormMessage />
         </FormItem>
       )}
     />