@tablestore/tablestore-agent-cli 0.2.9 → 0.2.11

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]/file-memory/[action]/route.ts

@@ -0,0 +1,92 @@
+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> = {
+  list: (client, request) =>
+    client.listFileMemories(
+      request as unknown as Parameters<MemoryClient["listFileMemories"]>[0],
+    ),
+  stat: (client, request) =>
+    client.statFileMemory(
+      request as unknown as Parameters<MemoryClient["statFileMemory"]>[0],
+    ),
+  read: (client, request) =>
+    client.readFileMemory(
+      request as unknown as Parameters<MemoryClient["readFileMemory"]>[0],
+    ),
+  create: (client, request) =>
+    client.createFileMemory(
+      request as unknown as Parameters<MemoryClient["createFileMemory"]>[0],
+    ),
+  update: (client, request) =>
+    client.updateFileMemory(
+      request as unknown as Parameters<MemoryClient["updateFileMemory"]>[0],
+    ),
+  rename: (client, request) =>
+    client.renameFileMemory(
+      request as unknown as Parameters<MemoryClient["renameFileMemory"]>[0],
+    ),
+  delete: (client, request) =>
+    client.deleteFileMemory(
+      request as unknown as Parameters<MemoryClient["deleteFileMemory"]>[0],
+    ),
+  "versions-list": (client, request) =>
+    client.listFileMemoryVersions(
+      request as unknown as Parameters<
+        MemoryClient["listFileMemoryVersions"]
+      >[0],
+    ),
+  "versions-get": (client, request) =>
+    client.getFileMemoryVersion(
+      request as unknown as Parameters<MemoryClient["getFileMemoryVersion"]>[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/components/chat/chat-config-context.tsx

@@ -16,13 +16,19 @@ import type {
 } from "@/hooks/use-chat-history";
 import { assembleRetrievalConfiguration } from "@/components/retrieval/assemble-retrieval-configuration";
 import { newId } from "@/lib/random-id";
+import {
+  FILEMEM_DEFAULT_RUN_ID,
+  normalizeMemoryRunId,
+  type StorageMode,
+} from "@/lib/memory-storage-mode";
 
 export type MountItem = ChatSessionMount;
 
 /**
  * 绑定里存的 scope 是*写* scope：四个字段都齐全且非通配符。
- * 服务端在检索时自行派生读 scope（agentId="*", runId="*"），客户端
- * 永远不发通配符。
+ * 服务端仅为结构化语义检索派生 app + tenant 级读 scope（保留 appId / tenantId，
+ * agentId / runId 为 "*"）；文件记忆仍使用精确 scope。客户端永远
+ * 不发通配符。
  */
 export interface ChatMemoryWriteScope {
   appId: string;
@@ -34,6 +40,7 @@ export interface ChatMemoryWriteScope {
 export interface ChatMemoryBinding {
   id: string;
   memoryStoreName: string;
+  storageMode?: StorageMode;
   scope: ChatMemoryWriteScope;
   topK?: number;
   autoSave: boolean;
@@ -173,12 +180,34 @@ export function reducer(
         .filter((m): m is MountItem => !!m);
       return { ...state, mounts: reordered };
     }
-    case "HYDRATE":
-      return { ...state, ...action.state };
+    case "HYDRATE": {
+      const memory = action.state.memory;
+      return {
+        ...state,
+        ...action.state,
+        ...(memory
+          ? {
+              memory: {
+                ...memory,
+                scope: {
+                  ...memory.scope,
+                  runId: normalizeMemoryRunId(
+                    memory.storageMode,
+                    memory.scope.runId,
+                  ),
+                },
+              },
+            }
+          : {}),
+      };
+    }
     // SET_MEMORY 同一绑定的 id 保持稳定；只有从无到有时才铸新 id，避免不必要的 React key 抖动。
     case "SET_MEMORY": {
       if (!action.binding) return { ...state, memory: undefined };
-      const runId = action.binding.scope.runId || newId("run");
+      const runId = normalizeMemoryRunId(
+        action.binding.storageMode,
+        action.binding.scope.runId,
+      );
       return {
         ...state,
         memory: {
@@ -191,12 +220,19 @@ export function reducer(
     case "UPDATE_MEMORY": {
       if (!state.memory) return state;
       const { scope: patchScope, ...rest } = action.patch;
+      const memory = {
+        ...state.memory,
+        ...rest,
+        scope: { ...state.memory.scope, ...(patchScope ?? {}) },
+      };
       return {
         ...state,
         memory: {
-          ...state.memory,
-          ...rest,
-          scope: { ...state.memory.scope, ...(patchScope ?? {}) },
+          ...memory,
+          scope: {
+            ...memory.scope,
+            runId: normalizeMemoryRunId(memory.storageMode, memory.scope.runId),
+          },
         },
       };
     }
@@ -330,11 +366,14 @@ export function buildRagFromMounts(state: ChatConfigState) {
 export function buildMemoryFromBinding(state: ChatConfigState) {
   const m = state.memory;
   if (!m) return undefined;
-  const { appId, tenantId, agentId, runId } = m.scope;
+  const { appId, tenantId, agentId } = m.scope;
+  const runId =
+    m.storageMode === "filemem" ? FILEMEM_DEFAULT_RUN_ID : m.scope.runId;
   if (!appId || !tenantId || !agentId || !runId) return undefined;
   return {
     memoryStoreName: m.memoryStoreName,
     scope: { appId, tenantId, agentId, runId },
+    ...(m.storageMode ? { storageMode: m.storageMode } : {}),
     ...(typeof m.topK === "number" ? { topK: m.topK } : {}),
     autoSave: m.autoSave,
     ...(m.retrievalMode ? { retrievalMode: m.retrievalMode } : {}),