@tablestore/tablestore-agent-cli 0.3.1 → 0.4.1

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

@@ -6,7 +6,7 @@ import { useForm, useFieldArray } from "react-hook-form";
 import { zodResolver } from "@hookform/resolvers/zod";
 import { z } from "zod";
 import { toast } from "sonner";
-import { Plus, Trash2 } from "lucide-react";
+import { HelpCircle, Plus, Trash2 } from "lucide-react";
 
 import { Button } from "@/components/ui/button";
 import { Checkbox } from "@/components/ui/checkbox";
@@ -21,6 +21,12 @@ import {
 import { Input } from "@/components/ui/input";
 import { Label } from "@/components/ui/label";
 import { Textarea } from "@/components/ui/textarea";
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipProvider,
+  TooltipTrigger,
+} from "@/components/ui/tooltip";
 import {
   Select,
   SelectContent,
@@ -36,6 +42,7 @@ import {
 import {
   Form,
   FormControl,
+  FormDescription,
   FormField,
   FormItem,
   FormLabel,
@@ -44,9 +51,18 @@ import {
 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 { MessageKey, TranslateFn } from "@/i18n/i18n-context";
+import {
+  DREAM_APPLICATION_MODES,
+  dreamModeForcedEffort,
+  normalizeDreamMode,
+} from "@/lib/dream-create-options";
+import { cn } from "@/lib/utils";
 import type {
   CreateDreamTaskRequest,
+  DreamApplyMode,
+  DreamEffort,
+  DreamScopeOutputMode,
   DreamTaskType,
   MemoryScope,
 } from "@/types/memory";
@@ -64,9 +80,9 @@ interface DreamSchemaMessages {
   atLeastOneNonWildcard: string;
   atLeastOneScope: string;
   scopesLimit: string;
-  agenticScopesLimit: string;
-  executionModeCombination: string;
-  taskTypeExecutionMode: string;
+  highEffortScopesLimit: string;
+  effortCombination: string;
+  taskTypeExactScope: string;
   instructionsLimit: string;
   maxSessionsRange: string;
   maxMessagesRange: string;
@@ -82,9 +98,9 @@ const DEFAULT_SCHEMA_MESSAGES: DreamSchemaMessages = {
   atLeastOneNonWildcard: "至少指定一个非通配符字段",
   atLeastOneScope: "至少一个 scope",
   scopesLimit: "scope 最多 20 个",
-  agenticScopesLimit: "Agentic Dream scope 最多 8 个",
-  executionModeCombination: "执行模式与应用模式组合无效",
-  taskTypeExecutionMode: "技能与画像任务不支持 multi_loop",
+  highEffortScopesLimit: "高 effort Dream scope 最多 8 个",
+  effortCombination: "effort 与应用模式组合无效",
+  taskTypeExactScope: "技能与画像任务必须且只能使用一个无通配符的精确 scope",
   instructionsLimit: "指令不能超过 4000 字节（UTF-8）",
   maxSessionsRange: "最大会话数必须是 0 到 100 之间的整数",
   maxMessagesRange: "最大消息数必须是 0 到 20000 之间的整数",
@@ -155,7 +171,7 @@ function createDreamFormSchema(messages: DreamSchemaMessages) {
   return z
     .object({
       taskType: z.enum(["memory", "skill", "profile"]),
-      executionMode: z.enum(["single_loop", "multi_loop"]),
+      effort: z.enum(["low", "high"]),
       scopes: z
         .array(scopeSchema)
         .min(1, messages.atLeastOneScope)
@@ -206,17 +222,25 @@ function createDreamFormSchema(messages: DreamSchemaMessages) {
       }
 
       if (values.taskType !== "memory") {
-        if (values.executionMode === "multi_loop") {
+        if (
+          values.effort === "high" &&
+          (values.scopes.length !== 1 ||
+            values.scopes.some((scope) =>
+              [scope.appId, scope.tenantId, scope.agentId, scope.runId].some(
+                (segment) => !segment || segment === "*",
+              ),
+            ))
+        ) {
           ctx.addIssue({
             code: z.ZodIssueCode.custom,
-            message: messages.taskTypeExecutionMode,
-            path: ["executionMode"],
+            message: messages.taskTypeExactScope,
+            path: ["scopes"],
           });
         }
         if (values.applyMode !== undefined) {
           ctx.addIssue({
             code: z.ZodIssueCode.custom,
-            message: messages.executionModeCombination,
+            message: messages.effortCombination,
             path: ["applyMode"],
           });
         }
@@ -226,33 +250,27 @@ function createDreamFormSchema(messages: DreamSchemaMessages) {
       if (values.applyMode === undefined) {
         ctx.addIssue({
           code: z.ZodIssueCode.custom,
-          message: messages.executionModeCombination,
+          message: messages.effortCombination,
           path: ["applyMode"],
         });
-      } else if (
-        values.executionMode === "single_loop" &&
-        values.applyMode === "plan"
-      ) {
+      } else if (values.effort === "low" && values.applyMode === "plan") {
         ctx.addIssue({
           code: z.ZodIssueCode.custom,
-          message: messages.executionModeCombination,
+          message: messages.effortCombination,
           path: ["applyMode"],
         });
-      } else if (
-        values.executionMode === "multi_loop" &&
-        values.applyMode === "proposal"
-      ) {
+      } else if (values.effort === "high" && values.applyMode === "proposal") {
         ctx.addIssue({
           code: z.ZodIssueCode.custom,
-          message: messages.executionModeCombination,
+          message: messages.effortCombination,
           path: ["applyMode"],
         });
       }
 
-      if (values.executionMode === "multi_loop" && values.scopes.length > 8) {
+      if (values.effort === "high" && values.scopes.length > 8) {
         ctx.addIssue({
           code: z.ZodIssueCode.custom,
-          message: messages.agenticScopesLimit,
+          message: messages.highEffortScopesLimit,
           path: ["scopes"],
         });
       }
@@ -270,9 +288,9 @@ function buildFormSchema(t: TranslateFn) {
     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"),
+    highEffortScopesLimit: t("memory.dream.highEffortScopesLimit"),
+    effortCombination: t("memory.dream.effortCombination"),
+    taskTypeExactScope: t("memory.dream.taskTypeExactScope"),
     instructionsLimit: t("memory.dream.instructionsLimit"),
     maxSessionsRange: t("memory.dream.maxSessionsRange"),
     maxMessagesRange: t("memory.dream.maxMessagesRange"),
@@ -287,6 +305,209 @@ function buildFormSchema(t: TranslateFn) {
 export type DreamCreateFormValues = z.infer<typeof dreamCreateFormSchema>;
 type FormValues = DreamCreateFormValues;
 
+const DREAM_EFFORTS = ["low", "high"] as const;
+
+export function dreamEffortOptions(
+  _taskType: DreamTaskType,
+): readonly (typeof DREAM_EFFORTS)[number][] {
+  return DREAM_EFFORTS;
+}
+
+export function normalizeTaskTypeChange(
+  taskType: DreamTaskType,
+  current: Pick<DreamCreateFormValues, "effort" | "applyMode" | "scopes"> &
+    Partial<
+      Pick<
+        DreamCreateFormValues,
+        | "scopeOutputMode"
+        | "thresholdAdd"
+        | "thresholdUpdate"
+        | "thresholdMerge"
+      >
+    >,
+) {
+  if (taskType === "memory") {
+    return {
+      ...current,
+      applyMode:
+        current.applyMode ??
+        (current.effort === "high" ? "safe_auto" : "proposal"),
+      scopeOutputMode: current.scopeOutputMode ?? "preserve_scope",
+    };
+  }
+  return {
+    ...current,
+    applyMode: undefined,
+    scopeOutputMode: undefined,
+    thresholdAdd: undefined,
+    thresholdUpdate: undefined,
+    thresholdMerge: undefined,
+    scopes:
+      current.effort === "high" ? current.scopes.slice(0, 1) : current.scopes,
+  };
+}
+
+const APPLICATION_MODE_KEYS: Record<
+  DreamApplyMode,
+  { title: MessageKey; summary: MessageKey; help: MessageKey }
+> = {
+  proposal: {
+    title: "memory.dream.applyModeRequestApproval",
+    summary: "memory.dream.applyModeRequestApprovalSummary",
+    help: "memory.dream.applyModeRequestApprovalHelp",
+  },
+  safe_auto: {
+    title: "memory.dream.applyModeHelpMeApprove",
+    summary: "memory.dream.applyModeHelpMeApproveSummary",
+    help: "memory.dream.applyModeHelpMeApproveHelp",
+  },
+  plan: {
+    title: "memory.dream.applyModePlanMode",
+    summary: "memory.dream.applyModePlanModeSummary",
+    help: "memory.dream.applyModePlanModeHelp",
+  },
+};
+
+export function DreamApplicationModeCards({
+  value,
+  effort,
+  onChange,
+  t,
+}: {
+  value: DreamApplyMode;
+  effort: DreamEffort;
+  onChange: (value: DreamApplyMode, effort: DreamEffort) => void;
+  t: TranslateFn;
+}) {
+  return (
+    <TooltipProvider delayDuration={150}>
+      <div
+        className="grid gap-2 sm:grid-cols-3"
+        role="radiogroup"
+        aria-label={t("memory.dream.applyMode")}
+      >
+        {DREAM_APPLICATION_MODES.map((mode) => {
+          const keys = APPLICATION_MODE_KEYS[mode.value];
+          const selected = value === mode.value;
+          return (
+            <div
+              key={mode.value}
+              className={cn(
+                "flex min-h-28 rounded-lg border bg-card transition-colors",
+                selected
+                  ? "border-primary bg-primary-soft ring-1 ring-primary/20"
+                  : "border-border hover:border-primary/40 hover:bg-muted/30",
+              )}
+            >
+              <button
+                type="button"
+                role="radio"
+                aria-checked={selected}
+                className="min-w-0 flex-1 rounded-l-lg p-3 text-left focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary"
+                onClick={() => {
+                  const normalized = normalizeDreamMode(mode.value, effort);
+                  onChange(normalized.applyMode, normalized.effort);
+                }}
+              >
+                <span className="block text-sm font-semibold">
+                  {t(keys.title)}
+                </span>
+                <span className="mt-1 block text-xs leading-5 text-muted-foreground">
+                  {t(keys.summary)}
+                </span>
+              </button>
+              <Tooltip>
+                <TooltipTrigger asChild>
+                  <button
+                    type="button"
+                    className="m-2 h-7 w-7 shrink-0 rounded-full text-muted-foreground hover:bg-muted hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary"
+                    aria-label={t("memory.dream.applyModeHelpLabel", {
+                      mode: t(keys.title),
+                    })}
+                  >
+                    <HelpCircle className="mx-auto h-4 w-4" />
+                  </button>
+                </TooltipTrigger>
+                <TooltipContent className="max-w-72 leading-5" side="top">
+                  {t(keys.help)}
+                </TooltipContent>
+              </Tooltip>
+            </div>
+          );
+        })}
+      </div>
+    </TooltipProvider>
+  );
+}
+
+const OUTPUT_LOCATIONS: ReadonlyArray<{
+  value: DreamScopeOutputMode;
+  title: MessageKey;
+  summary: MessageKey;
+}> = [
+  {
+    value: "preserve_scope",
+    title: "memory.dream.preserveScope",
+    summary: "memory.dream.preserveScopeSummary",
+  },
+  {
+    value: "promote_scope",
+    title: "memory.dream.promoteScope",
+    summary: "memory.dream.promoteScopeSummary",
+  },
+];
+
+export function DreamOutputLocationCards({
+  value,
+  onChange,
+  t,
+}: {
+  value: DreamScopeOutputMode;
+  onChange: (value: DreamScopeOutputMode) => void;
+  t: TranslateFn;
+}) {
+  return (
+    <div className="space-y-2">
+      <div
+        className="grid gap-2 sm:grid-cols-2"
+        role="radiogroup"
+        aria-label={t("memory.dream.scopeOutputMode")}
+      >
+        {OUTPUT_LOCATIONS.map((option) => {
+          const selected = value === option.value;
+          return (
+            <button
+              key={option.value}
+              type="button"
+              role="radio"
+              aria-checked={selected}
+              className={cn(
+                "rounded-lg border p-3 text-left transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary",
+                selected
+                  ? "border-primary bg-primary-soft ring-1 ring-primary/20"
+                  : "border-border hover:border-primary/40 hover:bg-muted/30",
+              )}
+              onClick={() => onChange(option.value)}
+            >
+              <span className="block text-sm font-semibold">
+                {t(option.title)}
+              </span>
+              <span className="mt-1 block text-xs leading-5 text-muted-foreground">
+                {t(option.summary)}
+              </span>
+            </button>
+          );
+        })}
+      </div>
+      {value === "promote_scope" ? (
+        <p className="rounded-md bg-muted/40 px-3 py-2 text-xs text-muted-foreground">
+          {t("memory.dream.promoteScopeHint")}
+        </p>
+      ) : null}
+    </div>
+  );
+}
+
 function parseOptionalInt(raw: string | undefined): number | undefined {
   if (raw === undefined || raw.trim() === "") return undefined;
   const n = Number(raw);
@@ -322,7 +543,7 @@ export function buildDreamCreateRequest(
       return result;
     }),
     taskType: values.taskType,
-    executionMode: values.executionMode,
+    effort: values.effort,
     incremental: Boolean(values.incremental),
     ...(isMemory && values.applyMode && { applyMode: values.applyMode }),
     ...(isMemory &&
@@ -397,8 +618,9 @@ function MemoryDreamCreateDialogInner({
               : "",
         },
       ],
-      executionMode: "single_loop",
+      effort: "low",
       applyMode: "proposal",
+      scopeOutputMode: "preserve_scope",
       incremental: false,
     },
   });
@@ -409,6 +631,9 @@ function MemoryDreamCreateDialogInner({
   });
 
   const taskType = form.watch("taskType");
+  const effort = form.watch("effort");
+  const applyMode = form.watch("applyMode") ?? "proposal";
+  const forcedEffort = dreamModeForcedEffort(applyMode);
   const isMemoryType = taskType === "memory";
 
   const [advancedOpen, setAdvancedOpen] = useState(false);
@@ -459,12 +684,25 @@ function MemoryDreamCreateDialogInner({
                   <Select
                     onValueChange={(value) => {
                       field.onChange(value);
-                      if (value === "memory") {
-                        form.setValue("applyMode", "proposal");
-                      } else {
-                        form.setValue("executionMode", "single_loop");
-                        form.setValue("applyMode", undefined);
-                      }
+                      const next = normalizeTaskTypeChange(
+                        value as DreamTaskType,
+                        {
+                          effort: form.getValues("effort"),
+                          applyMode: form.getValues("applyMode"),
+                          scopeOutputMode: form.getValues("scopeOutputMode"),
+                          thresholdAdd: form.getValues("thresholdAdd"),
+                          thresholdUpdate: form.getValues("thresholdUpdate"),
+                          thresholdMerge: form.getValues("thresholdMerge"),
+                          scopes: form.getValues("scopes"),
+                        },
+                      );
+                      form.setValue("effort", next.effort);
+                      form.setValue("applyMode", next.applyMode);
+                      form.setValue("scopeOutputMode", next.scopeOutputMode);
+                      form.setValue("thresholdAdd", next.thresholdAdd);
+                      form.setValue("thresholdUpdate", next.thresholdUpdate);
+                      form.setValue("thresholdMerge", next.thresholdMerge);
+                      form.setValue("scopes", next.scopes);
                     }}
                     value={field.value}
                   >
@@ -495,17 +733,24 @@ function MemoryDreamCreateDialogInner({
                 <Label className="text-sm font-medium">
                   {t("memory.common.scopeRange")}
                 </Label>
-                <Button
-                  type="button"
-                  size="sm"
-                  variant="ghost"
-                  onClick={() =>
-                    append({ appId: "", tenantId: "", agentId: "", runId: "" })
-                  }
-                >
-                  <Plus className="mr-1 h-3.5 w-3.5" />
-                  {t("memory.dream.addScope")}
-                </Button>
+                {(isMemoryType || effort === "low") && (
+                  <Button
+                    type="button"
+                    size="sm"
+                    variant="ghost"
+                    onClick={() =>
+                      append({
+                        appId: "",
+                        tenantId: "",
+                        agentId: "",
+                        runId: "",
+                      })
+                    }
+                  >
+                    <Plus className="mr-1 h-3.5 w-3.5" />
+                    {t("memory.dream.addScope")}
+                  </Button>
+                )}
               </div>
               <div className="space-y-3">
                 {fields.map((field, index) => (
@@ -571,28 +816,49 @@ function MemoryDreamCreateDialogInner({
               </div>
             </section>
 
-            <section className="grid gap-3 sm:grid-cols-3">
+            {isMemoryType ? (
               <FormField
                 control={form.control}
-                name="executionMode"
+                name="applyMode"
                 render={({ field }) => (
                   <FormItem>
-                    <FormLabel>{t("memory.dream.executionMode")}</FormLabel>
+                    <FormLabel>{t("memory.dream.applyMode")}</FormLabel>
+                    <DreamApplicationModeCards
+                      value={field.value ?? "proposal"}
+                      effort={effort}
+                      t={t}
+                      onChange={(value, normalizedEffort) => {
+                        field.onChange(value);
+                        form.setValue("effort", normalizedEffort, {
+                          shouldValidate: true,
+                        });
+                      }}
+                    />
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+            ) : null}
+
+            <section className="grid gap-3 sm:grid-cols-2">
+              <FormField
+                control={form.control}
+                name="effort"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>{t("memory.dream.effort")}</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");
+                        if (!isMemoryType && value === "high") {
+                          form.setValue(
+                            "scopes",
+                            form.getValues("scopes").slice(0, 1),
+                          );
                         }
                       }}
                       value={field.value}
+                      disabled={isMemoryType && forcedEffort !== undefined}
                     >
                       <FormControl>
                         <SelectTrigger>
@@ -600,99 +866,48 @@ function MemoryDreamCreateDialogInner({
                         </SelectTrigger>
                       </FormControl>
                       <SelectContent>
-                        <SelectItem value="single_loop">
-                          {t("memory.dream.executionModeSingle")}
-                        </SelectItem>
-                        {isMemoryType && (
-                          <SelectItem value="multi_loop">
-                            {t("memory.dream.executionModeMulti")}
+                        {dreamEffortOptions(taskType).map((level) => (
+                          <SelectItem key={level} value={level}>
+                            {level === "low"
+                              ? t("memory.dream.effortLow")
+                              : t("memory.dream.effortHigh")}
                           </SelectItem>
-                        )}
+                        ))}
                       </SelectContent>
                     </Select>
+                    {isMemoryType && forcedEffort ? (
+                      <FormDescription>
+                        {t(
+                          forcedEffort === "low"
+                            ? "memory.dream.effortLockedLow"
+                            : "memory.dream.effortLockedHigh",
+                        )}
+                      </FormDescription>
+                    ) : null}
                     <FormMessage />
                   </FormItem>
                 )}
               />
-              {isMemoryType && (
-                <FormField
-                  control={form.control}
-                  name="applyMode"
-                  render={({ field }) => (
-                    <FormItem>
-                      <FormLabel>{t("memory.dream.applyMode")}</FormLabel>
-                      <Select
-                        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>
-                            <SelectValue />
-                          </SelectTrigger>
-                        </FormControl>
-                        <SelectContent>
-                          <SelectItem value="proposal">
-                            {t("memory.dream.applyModeProposalOption")}
-                          </SelectItem>
-                          <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"
-                  render={({ field }) => (
-                    <FormItem>
-                      <FormLabel>{t("memory.dream.scopeOutputMode")}</FormLabel>
-                      <Select
-                        onValueChange={field.onChange}
-                        value={field.value ?? ""}
-                      >
-                        <FormControl>
-                          <SelectTrigger>
-                            <SelectValue
-                              placeholder={t(
-                                "memory.dream.scopeOutputModePlaceholder",
-                              )}
-                            />
-                          </SelectTrigger>
-                        </FormControl>
-                        <SelectContent>
-                          <SelectItem value="preserve_scope">
-                            {t("memory.dream.preserveScope")}
-                          </SelectItem>
-                          <SelectItem value="promote_scope">
-                            {t("memory.dream.promoteScope")}
-                          </SelectItem>
-                        </SelectContent>
-                      </Select>
-                      <FormMessage />
-                    </FormItem>
-                  )}
-                />
-              )}
             </section>
 
+            {isMemoryType ? (
+              <FormField
+                control={form.control}
+                name="scopeOutputMode"
+                render={({ field }) => (
+                  <FormItem>
+                    <FormLabel>{t("memory.dream.scopeOutputMode")}</FormLabel>
+                    <DreamOutputLocationCards
+                      value={field.value ?? "preserve_scope"}
+                      onChange={field.onChange}
+                      t={t}
+                    />
+                    <FormMessage />
+                  </FormItem>
+                )}
+              />
+            ) : null}
+
             <FormField
               control={form.control}
               name="instructions"