@tablestore/tablestore-agent-cli 0.2.11 → 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;
@@ -59,10 +64,14 @@ interface DreamSchemaMessages {
   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;
@@ -73,10 +82,14 @@ const DEFAULT_SCHEMA_MESSAGES: DreamSchemaMessages = {
   atLeastOneNonWildcard: "至少指定一个非通配符字段",
   atLeastOneScope: "至少一个 scope",
   scopesLimit: "scope 最多 20 个",
+  agenticScopesLimit: "Agentic Dream scope 最多 8 个",
+  executionModeCombination: "执行模式与应用模式组合无效",
+  taskTypeExecutionMode: "技能与画像任务不支持 multi_loop",
   instructionsLimit: "指令不能超过 4000 字节（UTF-8）",
-  maxSessionsRange: "最大会话数必须是 1 到 100 之间的整数",
-  maxMessagesRange: "最大消息数必须是 1 到 20000 之间的整数",
-  maxMemoriesRange: "最大记忆数必须是 1 到 5000 之间的整数",
+  maxSessionsRange: "最大会话数必须是 0 到 100 之间的整数",
+  maxMessagesRange: "最大消息数必须是 0 到 20000 之间的整数",
+  maxMemoriesRange: "最大记忆数必须是 0 到 5000 之间的整数",
+  expandedScopeLimitRange: "展开 scope 上限必须是 0 到 1000 之间的整数",
   thresholdRange: "置信度阈值必须在 0 到 1 之间",
   timestampInvalid: "时间格式不正确",
   timestampOrder: "最晚时间不能早于最早时间",
@@ -104,7 +117,7 @@ function optionalIntegerString(max: number, message: string) {
     .superRefine((value, ctx) => {
       if (!value) return;
       const parsed = Number(value);
-      if (!Number.isInteger(parsed) || parsed < 1 || parsed > max) {
+      if (!Number.isInteger(parsed) || parsed < 0 || parsed > max) {
         ctx.addIssue({ code: z.ZodIssueCode.custom, message });
       }
     });
@@ -142,17 +155,23 @@ function createDreamFormSchema(messages: DreamSchemaMessages) {
   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"]),
+      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()
@@ -170,18 +189,71 @@ function createDreamFormSchema(messages: DreamSchemaMessages) {
       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
+      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.timestampOrder,
-          path: ["maxTimestamp"],
+          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"],
         });
       }
     });
@@ -198,22 +270,27 @@ 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"),
     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<typeof dreamCreateFormSchema>;
+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;
 }
 
@@ -224,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} />;
@@ -265,7 +397,9 @@ function MemoryDreamCreateDialogInner({
               : "",
         },
       ],
+      executionMode: "single_loop",
       applyMode: "proposal",
+      incremental: false,
     },
   });
 
@@ -281,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"),
@@ -362,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>
@@ -468,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"
@@ -477,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>
@@ -492,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"
@@ -530,8 +690,8 @@ function MemoryDreamCreateDialogInner({
                     </FormItem>
                   )}
                 />
-              </section>
-            )}
+              )}
+            </section>
 
             <FormField
               control={form.control}
@@ -623,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")}
@@ -648,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>
 

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

@@ -0,0 +1,172 @@
+"use client";
+
+import { useState } from "react";
+import { toast } from "sonner";
+
+import { Button } from "@/components/ui/button";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { useApproveDreamPlan } from "@/hooks/use-approve-dream-plan";
+import { useI18n } from "@/i18n/i18n-context";
+import type { DreamPlan, DreamTaskStatus } from "@/types/memory";
+
+interface DreamPlanTask {
+  dreamId: string;
+  status: DreamTaskStatus;
+  plan?: DreamPlan;
+}
+
+export type DreamPlanDecision =
+  | { kind: "approve"; dreamId: string; approver: string }
+  | { kind: "cancel"; dreamId: string };
+
+export function buildDreamPlanDecision(
+  task: DreamPlanTask,
+  decision: "approve" | "reject",
+  approver?: string,
+): DreamPlanDecision {
+  if (task.status !== "awaiting_plan_approval") {
+    throw new Error(
+      `Dream task must be awaiting_plan_approval; current status is ${task.status}`,
+    );
+  }
+  if (decision === "reject") {
+    return { kind: "cancel", dreamId: task.dreamId };
+  }
+  if (
+    !task.plan ||
+    typeof task.plan.summary !== "string" ||
+    task.plan.summary.trim() === "" ||
+    !Array.isArray(task.plan.deleteMemoryIds) ||
+    !task.plan.deleteMemoryIds.every(
+      (memoryId) => typeof memoryId === "string" && memoryId.trim() !== "",
+    )
+  ) {
+    throw new Error("Dream task does not contain a valid plan");
+  }
+  const trimmedApprover = approver?.trim() ?? "";
+  if (trimmedApprover === "") {
+    throw new Error("Approver is required");
+  }
+  return {
+    kind: "approve",
+    dreamId: task.dreamId,
+    approver: trimmedApprover,
+  };
+}
+
+interface MemoryDreamPlanApprovalDialogProps {
+  memoryStoreName: string;
+  task: DreamPlanTask;
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+}
+
+export function MemoryDreamPlanApprovalDialog({
+  memoryStoreName,
+  task,
+  open,
+  onOpenChange,
+}: MemoryDreamPlanApprovalDialogProps) {
+  const { t } = useI18n();
+  const approveMutation = useApproveDreamPlan(memoryStoreName);
+  const [approver, setApprover] = useState("");
+
+  const handleOpenChange = (nextOpen: boolean) => {
+    if (!nextOpen) setApprover("");
+    onOpenChange(nextOpen);
+  };
+
+  const handleApprove = async () => {
+    try {
+      const decision = buildDreamPlanDecision(task, "approve", approver);
+      if (decision.kind !== "approve") return;
+      await approveMutation.mutateAsync({
+        dreamId: decision.dreamId,
+        approver: decision.approver,
+      });
+      toast.success(t("memory.dream.planApprovalSuccess"));
+      handleOpenChange(false);
+    } catch (error) {
+      toast.error(
+        error instanceof Error
+          ? error.message
+          : t("memory.dream.planApprovalFailed"),
+      );
+    }
+  };
+
+  const plan = task.plan;
+  return (
+    <Dialog open={open} onOpenChange={handleOpenChange}>
+      <DialogContent className="max-w-2xl">
+        <DialogHeader>
+          <DialogTitle>{t("memory.dream.planApprovalTitle")}</DialogTitle>
+          <DialogDescription>
+            {t("memory.dream.planApprovalDescription")}
+          </DialogDescription>
+        </DialogHeader>
+
+        <div className="space-y-4">
+          <section className="rounded-md border border-[hsl(var(--border))] p-3">
+            <h4 className="mb-1 text-xs font-semibold uppercase text-muted-foreground">
+              {t("memory.dream.planSummary")}
+            </h4>
+            <p className="whitespace-pre-wrap text-sm">{plan?.summary}</p>
+          </section>
+          <section className="rounded-md border border-[hsl(var(--border))] p-3">
+            <h4 className="mb-2 text-xs font-semibold uppercase text-muted-foreground">
+              {t("memory.dream.planDeletionWhitelist")}
+            </h4>
+            {plan?.deleteMemoryIds.length ? (
+              <ul className="space-y-1 font-mono text-xs">
+                {plan.deleteMemoryIds.map((memoryId) => (
+                  <li key={memoryId} className="break-all">
+                    {memoryId}
+                  </li>
+                ))}
+              </ul>
+            ) : (
+              <p className="text-sm text-muted-foreground">
+                {t("memory.dream.planNoDeletions")}
+              </p>
+            )}
+          </section>
+          <div className="space-y-2">
+            <Label htmlFor="dream-plan-approver">
+              {t("memory.dream.planApprover")}
+            </Label>
+            <Input
+              id="dream-plan-approver"
+              value={approver}
+              onChange={(event) => setApprover(event.target.value)}
+              placeholder={t("memory.dream.planApproverPlaceholder")}
+            />
+          </div>
+        </div>
+
+        <DialogFooter>
+          <Button variant="outline" onClick={() => handleOpenChange(false)}>
+            {t("common.cancel")}
+          </Button>
+          <Button
+            onClick={handleApprove}
+            disabled={approveMutation.isPending || approver.trim() === ""}
+          >
+            {approveMutation.isPending
+              ? t("memory.dream.planApproving")
+              : t("memory.dream.planApprove")}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}