@tablestore/tablestore-agent-cli 0.2.10 → 0.3.1

package/dist/dashboard-runtime/dashboard/src/app/api/v1/llm/chat/route.ts

@@ -30,10 +30,11 @@ import {
   formatMemoryBlock,
   type MemoryWriteScope,
 } from "./memory-helpers";
+import { formatFileMemoryBlock } from "./file-memory-helpers";
 import {
-  formatFileMemoryBlock,
-  runFileMemoryRetrieval,
-} from "./file-memory-helpers";
+  appendCuratedMemories,
+  extractDurableMemories,
+} from "./file-memory-curator";
 
 // Default aggregate cap when the client omits `rag.topK`.
 const DEFAULT_AGGREGATE_TOP_K = 20;
@@ -94,6 +95,7 @@ const MAX_HISTORY_MESSAGES = 20;
  * 用于控制 system 提示总长度，避免单个超长 chunk 把模型上下文挤爆。
  */
 const MAX_CHUNK_DISPLAY_LENGTH = 1200;
+const FILE_MEMORY_STORE_DESCRIBE_TIMEOUT_MS = 1_500;
 const chatLogger = createLogger("dashboard.api.llm");
 
 /**
@@ -245,7 +247,24 @@ export async function POST(request: NextRequest) {
   };
   // If the client disconnects mid-stream, propagate cancellation upstream so
   // we stop paying for tokens we'll never deliver.
-  request.signal.addEventListener("abort", cleanup, { once: true });
+  if (request.signal.aborted) {
+    cleanup();
+  } else {
+    request.signal.addEventListener("abort", cleanup, { once: true });
+  }
+
+  const storeExtractInstructionsPromise =
+    !upstreamAbort.signal.aborted &&
+    body.memory?.storageMode === "filemem" &&
+    body.memory.autoSave !== false &&
+    Boolean(body.memory.turnId) &&
+    memoryClient?.ok
+      ? getStoreExtractInstructions(
+          memoryClient.client,
+          body.memory.memoryStoreName,
+          upstreamAbort.signal,
+        )
+      : undefined;
 
   const stream = new ReadableStream<Uint8Array>({
     async start(controller) {
@@ -346,37 +365,36 @@ export async function POST(request: NextRequest) {
             chunks.length > 0 ? queryForMemory : lastUser.content;
           emit({ type: "memory.start", query: memoryQuery });
           if (isFileMemory) {
-            // 文件记忆（openclaw local 模式同款）：挂载同步 → 本地词法检索。
-            // 同步失败在 runFileMemoryRetrieval 内部降级为「用本地旧副本」，
-            // 只有意外异常才落到 catch —— 与语义检索一样不阻塞主流。
-            try {
-              const fm = await runFileMemoryRetrieval({
-                memoryClient: memoryClient.client,
-                otsInstanceName: memoryClient.otsInstanceName,
-                memoryStoreName: body.memory.memoryStoreName,
-                scope: body.memory.scope as MemoryWriteScope,
-                query: memoryQuery,
-                topK: body.memory.topK ?? 5,
-              });
-              emit({
-                type: "memory.files",
-                scopeDir: fm.scopeDir,
-                files: fm.files,
-                sync: fm.sync,
-              });
-              memoryHits = fm.hits.map((h) => ({
-                unit: { text: h.unit.text },
-                score: h.score,
-                source: h.unit.source,
-              }));
-              memoryBlock = formatFileMemoryBlock(fm.scopeDir, fm.hits);
-            } catch (err) {
-              chatLogger.warn({
-                event: "api.memory.file_memory_exception",
-                message: err instanceof Error ? err.message : String(err),
-                error: err,
-              });
-            }
+            // Projection files and lexical search live only in the browser
+            // tab. The BFF accepts a bounded evidence set and never touches a
+            // server-local mirror.
+            const fileContext = body.memory.fileContext ?? {
+              files: [],
+              hits: [],
+              cache: {
+                ok: false,
+                listed: 0,
+                loaded: 0,
+                reused: 0,
+                totalBytes: 0,
+                truncated: false,
+                error: "浏览器未提供文件缓存",
+              },
+            };
+            emit({
+              type: "memory.files",
+              files: fileContext.files,
+              cache: fileContext.cache,
+              memoryStoreName: body.memory.memoryStoreName,
+              writable: body.memory.storageMode === "filemem",
+              scope: body.memory.scope,
+            });
+            memoryHits = fileContext.hits.map((hit) => ({
+              unit: { text: hit.text },
+              score: hit.score,
+              source: hit.source,
+            }));
+            memoryBlock = formatFileMemoryBlock(fileContext.hits);
           } else {
             const readScope = deriveReadScope(
               body.memory.scope as MemoryWriteScope,
@@ -435,25 +453,91 @@ export async function POST(request: NextRequest) {
 
         const reader = upstream.getReader();
         let assistantContent = "";
+        let completionUsage:
+          { promptTokens?: number; completionTokens?: number } | undefined;
+        let upstreamFailed = false;
         while (true) {
           const { value, done } = await reader.read();
           if (done) break;
           if (value.type === "content.delta") {
             assistantContent += value.delta;
           }
+          if (value.type === "done") {
+            completionUsage = value.usage;
+            break;
+          }
           emit(value);
-          if (value.type === "done" || value.type === "error") {
+          if (value.type === "error") {
+            upstreamFailed = true;
             break;
           }
         }
+        // ---- filemem 智能提炼写回 ----
+        // 与结构化记忆的原始消息归档不同，filemem 先让模型筛选耐久事实，
+        // 再以幂等 turn marker + SHA CAS 追加到日期日记。终态 done 延迟到
+        // 本步骤之后，确保浏览器能可靠收到保存结果。
+        if (
+          !upstreamFailed &&
+          body.memory?.storageMode === "filemem" &&
+          body.memory.autoSave !== false &&
+          assistantContent.length > 0
+        ) {
+          if (!body.memory.turnId) {
+            emit({
+              type: "memory.save.skipped",
+              reason: "filemem auto-save requires turnId",
+            });
+          } else if (memoryClient?.ok) {
+            emit({ type: "memory.save.start" });
+            try {
+              const extractInstructions = await storeExtractInstructionsPromise;
+              const memories = await extractDurableMemories({
+                provider,
+                model: body.model,
+                messages: body.messages,
+                assistantContent,
+                existingHits: body.memory.fileContext?.hits ?? [],
+                extractInstructions,
+                signal: upstreamAbort.signal,
+              });
+              upstreamAbort.signal.throwIfAborted();
+              const result = await appendCuratedMemories({
+                client: memoryClient.client,
+                memoryStoreName: body.memory.memoryStoreName,
+                scope: body.memory.scope,
+                turnId: body.memory.turnId,
+                memories,
+                signal: upstreamAbort.signal,
+              });
+              emit({
+                type: "memory.save.done",
+                status: result.status,
+                count: result.count,
+                ...(result.status === "saved" ? { path: result.path } : {}),
+              });
+            } catch (err) {
+              if (!upstreamAbort.signal.aborted) {
+                const reason = err instanceof Error ? err.message : String(err);
+                emit({ type: "memory.save.skipped", reason });
+                chatLogger.warn({
+                  event: "api.file_memory.curate_failed",
+                  message: reason,
+                  error: err,
+                });
+              }
+            }
+          }
+        }
         // ---- Fire-and-forget 写回 ----
         // 必须放在 close() 之前 schedule，但执行可以晚于 close()：
         // 我们用一个不 await 的 IIFE 让它脱离 SSE controller 的生命周期。
         if (
           body.memory &&
           memoryClient?.ok &&
+          body.memory.storageMode !== "filemem" &&
           body.memory.autoSave !== false &&
           assistantContent.length > 0 &&
+          !upstreamAbort.signal.aborted &&
           !shouldSkipDuplicateTurn(body.memory.turnId)
         ) {
           const writeScope = body.memory.scope as MemoryWriteScope;
@@ -502,6 +586,9 @@ export async function POST(request: NextRequest) {
             }
           })();
         }
+        if (!upstreamFailed && !upstreamAbort.signal.aborted) {
+          emit({ type: "done", usage: completionUsage });
+        }
         chatLogger.info({
           event: "api.stream_response",
           message: "LLM chat stream completed",
@@ -603,8 +690,6 @@ async function resolveMemoryClient(request: NextRequest): Promise<
   | {
       ok: true;
       client: import("@tablestore/tablestore-agent-sdk").MemoryClient;
-      /** 文件记忆的本地镜像目录按 OTS 实例名分层，随凭据一起解析出来。 */
-      otsInstanceName: string;
     }
   | { ok: false; status: number; code: string; message: string }
 > {
@@ -621,10 +706,86 @@ async function resolveMemoryClient(request: NextRequest): Promise<
   return {
     ok: true,
     client: resolved.memory,
-    otsInstanceName: resolved.config?.ots_instance_name ?? "",
   };
 }
 
+async function getStoreExtractInstructions(
+  client: import("@tablestore/tablestore-agent-sdk").MemoryClient,
+  memoryStoreName: string,
+  signal: AbortSignal,
+): Promise<string | undefined> {
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  let onAbort: (() => void) | undefined;
+  try {
+    const describe = Promise.resolve(
+      client.getMemoryStore({ memoryStoreName }),
+    );
+    const deadline = new Promise<never>((_, reject) => {
+      timeout = setTimeout(
+        () => reject(new FileMemoryStoreDescribeTimeoutError()),
+        FILE_MEMORY_STORE_DESCRIBE_TIMEOUT_MS,
+      );
+    });
+    const aborted = new Promise<never>((_, reject) => {
+      onAbort = () =>
+        reject(
+          signal.reason ??
+            new DOMException("The operation was aborted", "AbortError"),
+        );
+      if (signal.aborted) {
+        onAbort();
+      } else {
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+    });
+    const response = await Promise.race([describe, deadline, aborted]);
+    if (response.code !== "SUCCESS") {
+      chatLogger.warn({
+        event: "api.file_memory.store_describe_failed",
+        message: response.message ?? "getMemoryStore returned non-SUCCESS",
+        details: { code: response.code },
+      });
+      return undefined;
+    }
+
+    const data = response.data;
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
+      return undefined;
+    }
+    const extractInstructions = (data as Record<string, unknown>)[
+      "extractInstructions"
+    ];
+    return typeof extractInstructions === "string" &&
+      extractInstructions.trim().length > 0
+      ? extractInstructions
+      : undefined;
+  } catch (error) {
+    const event = signal.aborted
+      ? "api.file_memory.store_describe_aborted"
+      : error instanceof FileMemoryStoreDescribeTimeoutError
+        ? "api.file_memory.store_describe_timeout"
+        : "api.file_memory.store_describe_exception";
+    chatLogger.warn({
+      event,
+      message: error instanceof Error ? error.message : String(error),
+      error,
+    });
+    return undefined;
+  } finally {
+    if (timeout) clearTimeout(timeout);
+    if (onAbort) signal.removeEventListener("abort", onAbort);
+  }
+}
+
+class FileMemoryStoreDescribeTimeoutError extends Error {
+  constructor() {
+    super(
+      `getMemoryStore exceeded ${FILE_MEMORY_STORE_DESCRIBE_TIMEOUT_MS}ms deadline`,
+    );
+    this.name = "FileMemoryStoreDescribeTimeoutError";
+  }
+}
+
 /** @internal Exported for unit testing multimodal message construction. */
 export function buildFinalMessages(
   userSystemPrompt: string,

package/dist/dashboard-runtime/dashboard/src/app/api/v1/memory/stores/[store]/dream-tasks/[dreamId]/actions/apply/route.ts

@@ -12,10 +12,9 @@ import {
 /**
  * POST /api/v1/memory/stores/:store/dream-tasks/:dreamId/actions/apply
  *
- * Apply the supplied action ids to the memory store. Body shape:
- *   { actionIds: string[]; applier?: string }
- * The route validates the actionIds shape locally so a malformed body
- * doesn't reach the engine's per-action retry loop.
+ * Apply selected actions or approve an Agentic Dream plan. Body shape:
+ *   { mode: "actions"; actionIds: string[]; applier?: string }
+ *   { mode: "plan"; approver: string }
  */
 interface RouteContext {
   params: Promise<{ store: string; dreamId: string }>;
@@ -39,22 +38,56 @@ export async function POST(request: NextRequest, context: RouteContext) {
       });
     }
 
+    if (body.mode === "plan") {
+      const approver =
+        typeof body.approver === "string" ? body.approver.trim() : "";
+      if (approver === "" || body.actionIds !== undefined) {
+        return forwardResponse({
+          code: "BAD_REQUEST",
+          data: null,
+          message:
+            "mode=plan requires a non-empty approver and must not carry actionIds",
+        });
+      }
+      const response = await memory.applyMemoryDreamActions({
+        memoryStoreName: store,
+        dreamId,
+        mode: "plan",
+        approver,
+      });
+      return forwardResponse(response);
+    }
+
+    if (body.mode !== "actions" && body.mode !== undefined) {
+      return forwardResponse({
+        code: "BAD_REQUEST",
+        data: null,
+        message: "mode must be actions or plan",
+      });
+    }
+
     const actionIds = body.actionIds;
     if (
       !Array.isArray(actionIds) ||
       actionIds.length === 0 ||
-      !actionIds.every((id) => typeof id === "string" && id.length > 0)
+      actionIds.length > 100 ||
+      !actionIds.every(
+        (id) => typeof id === "string" && id.trim().length > 0,
+      ) ||
+      body.approver !== undefined
     ) {
       return forwardResponse({
         code: "BAD_REQUEST",
         data: null,
-        message: "actionIds must be a non-empty array of non-empty strings",
+        message:
+          "mode=actions requires 1 to 100 non-empty actionIds and must not carry approver",
       });
     }
 
     const sdkRequest: Record<string, unknown> = {
       memoryStoreName: store,
       dreamId,
+      mode: "actions",
       actionIds,
     };
     if (typeof body.applier === "string" && body.applier) {

package/dist/dashboard-runtime/dashboard/src/app/api/v1/memory/stores/[store]/file-memory/[action]/route.ts

@@ -0,0 +1,86 @@
+import { type NextRequest } from "next/server";
+
+import type { MemoryClient } from "@tablestore/tablestore-agent-sdk";
+
+import {
+  errorResponse,
+  forwardResponse,
+  handleApiError,
+  requireClients,
+} from "@/lib/server/api-helpers";
+
+import { parseFileMemoryRequest } from "../_request";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+interface RouteContext {
+  params: Promise<{ store: string; action: string }>;
+}
+
+type RequestBody = Record<string, unknown>;
+type Dispatcher = (
+  client: MemoryClient,
+  request: RequestBody,
+) => Promise<unknown>;
+
+const dispatchers: Record<string, Dispatcher> = {
+  add: (client, request) =>
+    client.addItem(
+      request as unknown as Parameters<MemoryClient["addItem"]>[0],
+    ),
+  list: (client, request) =>
+    client.listItems(
+      request as unknown as Parameters<MemoryClient["listItems"]>[0],
+    ),
+  get: (client, request) =>
+    client.getItem(
+      request as unknown as Parameters<MemoryClient["getItem"]>[0],
+    ),
+  update: (client, request) =>
+    client.updateItem(
+      request as unknown as Parameters<MemoryClient["updateItem"]>[0],
+    ),
+  delete: (client, request) =>
+    client.deleteItem(
+      request as unknown as Parameters<MemoryClient["deleteItem"]>[0],
+    ),
+  "versions-list": (client, request) =>
+    client.listItemVersions(
+      request as unknown as Parameters<MemoryClient["listItemVersions"]>[0],
+    ),
+  "version-get": (client, request) =>
+    client.getItemVersion(
+      request as unknown as Parameters<MemoryClient["getItemVersion"]>[0],
+    ),
+  "version-redact": (client, request) =>
+    client.redactItemVersion(
+      request as unknown as Parameters<MemoryClient["redactItemVersion"]>[0],
+    ),
+};
+
+export async function POST(request: NextRequest, context: RouteContext) {
+  try {
+    const { store, action } = await context.params;
+    const dispatch = dispatchers[action];
+    if (!dispatch) {
+      return errorResponse("NOT_FOUND", "Unknown file memory action", 404);
+    }
+
+    const auth = requireClients(request);
+    if (!("memory" in auth)) return auth;
+
+    const parsed = await parseFileMemoryRequest(request);
+    if (!parsed.ok) return parsed.response;
+
+    const { memoryStoreName: _ignored, ...safeBody } = parsed.body;
+    void _ignored;
+    const response = await dispatch(auth.memory, {
+      ...safeBody,
+      memoryStoreName: store,
+    });
+    return forwardResponse(response as Parameters<typeof forwardResponse>[0]);
+  } catch (error) {
+    return handleApiError(error);
+  }
+}

package/dist/dashboard-runtime/dashboard/src/app/api/v1/memory/stores/[store]/file-memory/_helpers.ts

@@ -1,42 +1,32 @@
-import {
-  defaultFileMemoryRoot,
-  fileMemoryScopeDir,
-  normalizeMountScope,
-  type MountScope,
-} from "@tablestore/tablestore-agent-sdk";
+export interface ExactFileMemoryScope {
+  appId: string;
+  tenantId: string;
+  agentId: string;
+  runId: string;
+}
 
 /**
- * 从 query / body 里读出文件记忆挂载 scope。appId 必填；其余空字段由
- * normalizeMountScope 归一化成 `__default__`（openclaw 同款，禁通配符）。
- * appId 缺失时返回 null，调用方回 400。
+ * File APIs only accept a concrete four-part scope. Unlike structured-memory
+ * searches, file operations never widen missing components or accept `*`.
  */
-export function readMountScope(
-  raw: Record<string, unknown> | URLSearchParams | null | undefined,
-): MountScope | null {
-  const get = (key: string): string => {
-    if (raw instanceof URLSearchParams) {
-      return raw.get(key) ?? "";
-    }
-    const value = raw?.[key];
-    return typeof value === "string" ? value : "";
+export function readExactFileMemoryScope(
+  raw: unknown,
+): ExactFileMemoryScope | null {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+
+  const value = raw as Record<string, unknown>;
+  const read = (key: "appId" | "tenantId" | "agentId" | "runId") => {
+    const component = value[key];
+    if (typeof component !== "string") return null;
+    const normalized = component.trim();
+    return normalized && normalized !== "*" ? normalized : null;
   };
-  const appId = get("appId").trim();
-  if (!appId || appId === "*") return null;
-  return normalizeMountScope({
-    appId,
-    tenantId: get("tenantId"),
-    agentId: get("agentId"),
-    runId: get("runId"),
-  });
-}
 
-/** store + 实例名 + scope → 本地镜像 scope 目录（与 CLI 共享的约定）。
- *  目录按 user 粒度聚合，同一用户不同会话共享同一路径。 */
-export function resolveScopeDir(
-  otsInstanceName: string,
-  store: string,
-  scope: MountScope,
-): { localRoot: string; scopeDir: string } {
-  const localRoot = defaultFileMemoryRoot(otsInstanceName, store);
-  return { localRoot, scopeDir: fileMemoryScopeDir(localRoot, scope) };
+  const appId = read("appId");
+  const tenantId = read("tenantId");
+  const agentId = read("agentId");
+  const runId = read("runId");
+  if (!appId || !tenantId || !agentId || !runId) return null;
+
+  return { appId, tenantId, agentId, runId };
 }

package/dist/dashboard-runtime/dashboard/src/app/api/v1/memory/stores/[store]/file-memory/_request.ts

@@ -0,0 +1,49 @@
+import { type NextRequest, type NextResponse } from "next/server";
+
+import { errorResponse } from "@/lib/server/api-helpers";
+
+import { readExactFileMemoryScope } from "./_helpers";
+
+type ParsedFileMemoryRequest =
+  | { ok: true; body: Record<string, unknown> }
+  | { ok: false; response: NextResponse };
+
+export async function parseFileMemoryRequest(
+  request: NextRequest,
+): Promise<ParsedFileMemoryRequest> {
+  let raw: unknown;
+  try {
+    raw = await request.json();
+  } catch {
+    return {
+      ok: false,
+      response: errorResponse("BAD_REQUEST", "Request body must be JSON", 400),
+    };
+  }
+
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return {
+      ok: false,
+      response: errorResponse(
+        "BAD_REQUEST",
+        "Request body must be a JSON object",
+        400,
+      ),
+    };
+  }
+
+  const body = raw as Record<string, unknown>;
+  const scope = readExactFileMemoryScope(body.scope);
+  if (!scope) {
+    return {
+      ok: false,
+      response: errorResponse(
+        "BAD_REQUEST",
+        "scope must contain exact appId, tenantId, agentId, and runId values",
+        400,
+      ),
+    };
+  }
+
+  return { ok: true, body: { ...body, scope } };
+}

package/dist/dashboard-runtime/dashboard/src/app/onboarding/page.tsx

@@ -1,6 +1,5 @@
 "use client";
 
-import { useRouter } from "next/navigation";
 import { Sparkles } from "lucide-react";
 
 import { ConnectInstanceForm } from "@/components/instance/connect-instance-form";
@@ -13,7 +12,6 @@ import type {
 import { useI18n } from "@/i18n/i18n-context";
 
 export default function OnboardingPage() {
-  const router = useRouter();
   const { t } = useI18n();
   const connect = useConnectInstance();
   const importByToken = useImportInstance();
@@ -27,7 +25,7 @@ export default function OnboardingPage() {
     } else {
       await connect.mutateAsync(values);
     }
-    router.replace("/chat");
+    window.location.replace("/");
   }
 
   return (