@tablestore/tablestore-agent-cli 0.2.10 → 0.3.1

package/dist/dashboard-runtime/dashboard/src/hooks/use-file-memory.ts

@@ -1,50 +1,206 @@
-import { useMutation, useQuery } from "@tanstack/react-query";
+import {
+  useInfiniteQuery,
+  useMutation,
+  useQuery,
+  useQueryClient,
+} from "@tanstack/react-query";
 
-import type { ChatMemoryWriteScope } from "@/components/chat/chat-config-context";
+import { fileMemoryQueryKeys } from "@/lib/query-keys";
+import { useDataScopeKey } from "@/providers/runtime-context-provider";
 import {
-  getFileMemoryFile,
-  getFileMemoryTree,
-  syncFileMemory,
+  addItem,
+  deleteItem,
+  getItem,
+  getItemVersion,
+  listItems,
+  listItemVersions,
+  redactItemVersion,
+  updateItem,
 } from "@/services/file-memory";
+import type {
+  AddItemRequest,
+  DeleteItemRequest,
+  FileMemoryScope,
+  GetItemRequest,
+  ListItemsRequest,
+  ListItemVersionsRequest,
+  RedactItemVersionRequest,
+  UpdateItemRequest,
+} from "@/types/file-memory";
+
+export { fileMemoryQueryKeys };
+
+function isExactScope(
+  scope: FileMemoryScope | undefined,
+): scope is FileMemoryScope {
+  return Boolean(
+    scope &&
+    scope.appId &&
+    scope.tenantId &&
+    scope.agentId &&
+    scope.runId &&
+    !Object.values(scope).includes("*"),
+  );
+}
 
-// 文件记忆挂载只要求 appId（其余空字段由 BFF 归一为 __default__，与 openclaw
-// 一致）；通配符不受支持，由调用方在启用前排除。
-function scopeUsable(scope: ChatMemoryWriteScope): boolean {
-  return Boolean(scope.appId);
+export function useItems(
+  memoryStoreName: string | undefined,
+  scope: FileMemoryScope | undefined,
+  options: Pick<ListItemsRequest, "pathPrefix" | "depth" | "view" | "limit"> & {
+    enabled?: boolean;
+  } = {},
+) {
+  const dataScopeKey = useDataScopeKey();
+  return useInfiniteQuery({
+    queryKey: fileMemoryQueryKeys.list(
+      dataScopeKey,
+      memoryStoreName ?? "",
+      scope!,
+      options.pathPrefix,
+    ),
+    queryFn: ({ pageParam }) =>
+      listItems(memoryStoreName!, {
+        scope: scope!,
+        ...(options.pathPrefix ? { pathPrefix: options.pathPrefix } : {}),
+        ...(options.depth !== undefined ? { depth: options.depth } : {}),
+        ...(options.view ? { view: options.view } : {}),
+        ...(options.limit ? { limit: options.limit } : {}),
+        ...(typeof pageParam === "string" ? { nextToken: pageParam } : {}),
+      }),
+    getNextPageParam: (last) => last.nextToken ?? undefined,
+    initialPageParam: undefined as string | undefined,
+    enabled:
+      options.enabled !== false && !!memoryStoreName && isExactScope(scope),
+  });
 }
 
-/** 只读本地镜像文件树。scope 不完整或未启用时不发请求。 */
-export function useFileMemoryTree(
+type ItemAddress = Pick<GetItemRequest, "itemId" | "path">;
+
+export function useItem(
   memoryStoreName: string | undefined,
-  scope: ChatMemoryWriteScope | undefined,
-  enabled: boolean,
+  scope: FileMemoryScope | undefined,
+  address: ItemAddress | null,
 ) {
+  const dataScopeKey = useDataScopeKey();
+  const addressKey = address?.itemId ?? address?.path ?? "";
   return useQuery({
-    queryKey: ["file-memory-tree", memoryStoreName, scope],
-    queryFn: () => getFileMemoryTree(memoryStoreName!, scope!),
-    enabled: enabled && !!memoryStoreName && !!scope && scopeUsable(scope),
+    queryKey: fileMemoryQueryKeys.item(
+      dataScopeKey,
+      memoryStoreName ?? "",
+      scope!,
+      addressKey,
+    ),
+    queryFn: () =>
+      getItem(memoryStoreName!, {
+        scope: scope!,
+        ...address!,
+        view: "full",
+      }),
+    enabled: !!memoryStoreName && isExactScope(scope) && !!addressKey,
+  });
+}
+
+export function useItemVersions(
+  memoryStoreName: string | undefined,
+  scope: FileMemoryScope | undefined,
+  itemId: string | undefined,
+  options: Pick<
+    ListItemVersionsRequest,
+    | "sessionId"
+    | "apiKeyId"
+    | "createdAtGte"
+    | "createdAtLte"
+    | "operation"
+    | "view"
+    | "limit"
+  > = {},
+) {
+  const dataScopeKey = useDataScopeKey();
+  return useInfiniteQuery({
+    queryKey: fileMemoryQueryKeys.versions(
+      dataScopeKey,
+      memoryStoreName ?? "",
+      scope!,
+      itemId ?? "",
+    ),
+    queryFn: ({ pageParam }) =>
+      listItemVersions(memoryStoreName!, {
+        scope: scope!,
+        itemId: itemId!,
+        ...options,
+        ...(typeof pageParam === "string" ? { nextToken: pageParam } : {}),
+      }),
+    getNextPageParam: (last) => last.nextToken ?? undefined,
+    initialPageParam: undefined as string | undefined,
+    enabled: !!memoryStoreName && isExactScope(scope) && !!itemId,
   });
 }
 
-/** 读取单个文件内容。传入 null rel 时不发请求。 */
-export function useFileMemoryFile(
+export function useItemVersion(
   memoryStoreName: string | undefined,
-  scope: ChatMemoryWriteScope | undefined,
-  rel: string | null,
+  scope: FileMemoryScope | undefined,
+  versionId: string | undefined,
 ) {
+  const dataScopeKey = useDataScopeKey();
   return useQuery({
-    queryKey: ["file-memory-file", memoryStoreName, scope, rel],
-    queryFn: () => getFileMemoryFile(memoryStoreName!, scope!, rel!),
-    enabled: !!memoryStoreName && !!scope && scopeUsable(scope) && !!rel,
+    queryKey: fileMemoryQueryKeys.version(
+      dataScopeKey,
+      memoryStoreName ?? "",
+      scope!,
+      versionId ?? "",
+    ),
+    queryFn: () =>
+      getItemVersion(memoryStoreName!, {
+        scope: scope!,
+        versionId: versionId!,
+        view: "full",
+      }),
+    enabled: !!memoryStoreName && isExactScope(scope) && !!versionId,
   });
 }
 
-/** 手动触发一次远端→本地同步。 */
-export function useSyncFileMemory() {
+type MutationVariables<TRequest> = TRequest & { memoryStoreName: string };
+
+function useItemMutation<TRequest extends { scope: FileMemoryScope }, TResult>(
+  mutate: (memoryStoreName: string, request: TRequest) => Promise<TResult>,
+) {
+  const dataScopeKey = useDataScopeKey();
+  const queryClient = useQueryClient();
   return useMutation({
-    mutationFn: (vars: {
-      memoryStoreName: string;
-      scope: ChatMemoryWriteScope;
-    }) => syncFileMemory(vars.memoryStoreName, vars.scope),
+    mutationFn: ({
+      memoryStoreName,
+      ...request
+    }: MutationVariables<TRequest>) =>
+      mutate(memoryStoreName, request as unknown as TRequest),
+    onSuccess: (_data, variables) =>
+      queryClient.invalidateQueries({
+        queryKey: fileMemoryQueryKeys.root(
+          dataScopeKey,
+          variables.memoryStoreName,
+          variables.scope,
+        ),
+      }),
   });
 }
+
+export function useAddItem() {
+  return useItemMutation(addItem);
+}
+
+export function useUpdateItem() {
+  return useItemMutation(updateItem);
+}
+
+export function useDeleteItem() {
+  return useItemMutation(deleteItem);
+}
+
+export function useRedactItemVersion() {
+  return useItemMutation(redactItemVersion);
+}
+
+export type AddItemVariables = MutationVariables<AddItemRequest>;
+export type UpdateItemVariables = MutationVariables<UpdateItemRequest>;
+export type DeleteItemVariables = MutationVariables<DeleteItemRequest>;
+export type RedactItemVersionVariables =
+  MutationVariables<RedactItemVersionRequest>;

package/dist/dashboard-runtime/dashboard/src/hooks/use-instances.ts

@@ -11,6 +11,7 @@ import {
   deleteInstance,
   exportInstanceToken,
   getInstance,
+  getInstanceConnectivity,
   importInstance,
   listInstances,
   switchInstance,
@@ -32,9 +33,22 @@ import {
   useRuntimeContext,
 } from "@/providers/runtime-context-provider";
 import { useI18n } from "@/i18n/i18n-context";
+import type { RuntimeContext } from "@/types/runtime-context";
 
 export const INSTANCES_QUERY_KEY = ["instances"] as const;
 
+export function resolveDisplayedInstanceName(
+  context: Pick<
+    RuntimeContext,
+    "activeInstance" | "credentialSource" | "instanceName"
+  >,
+  configuredActiveInstance: string | null,
+): string | null {
+  return (
+    context.activeInstance ?? context.instanceName ?? configuredActiveInstance
+  );
+}
+
 /** Invalidate every cache whose data depends on the active instance.
  *  Used after non-switch mutations (connect / import / update / delete) where
  *  the current session can keep the existing data while a refetch lands. */
@@ -56,13 +70,35 @@ function refreshRuntimeContext(queryClient: QueryClient) {
   void queryClient.invalidateQueries({ queryKey: RUNTIME_CONTEXT_QUERY_KEY });
 }
 
+function invalidateInstanceConnectivity(queryClient: QueryClient) {
+  void queryClient.invalidateQueries({ queryKey: ["instance-connectivity"] });
+}
+
 export function useInstances() {
   const { context, ready } = useRuntimeContext();
   return useQuery({
     queryKey: queryKeys.instances(context.dataScopeKey),
     queryFn: listInstances,
+    select: (data) => ({
+      ...data,
+      activeInstance: resolveDisplayedInstanceName(
+        context,
+        data.activeInstance,
+      ),
+    }),
+    enabled: ready,
+    staleTime: 30 * 1000,
+  });
+}
+
+export function useInstanceConnectivity() {
+  const { context, ready } = useRuntimeContext();
+  return useQuery({
+    queryKey: queryKeys.instanceConnectivity(context.dataScopeKey),
+    queryFn: getInstanceConnectivity,
     enabled: ready,
     staleTime: 30 * 1000,
+    refetchInterval: 30 * 1000,
   });
 }
 
@@ -83,6 +119,7 @@ export function useConnectInstance() {
     mutationFn: (payload: ConnectInstancePayload) => connectInstance(payload),
     onSuccess: () => {
       resetInstanceScopedCaches(queryClient);
+      invalidateInstanceConnectivity(queryClient);
       refreshRuntimeContext(queryClient);
       toast.success(t("instance.toast.created"));
     },
@@ -103,6 +140,7 @@ export function useImportInstance() {
     mutationFn: (payload: ImportInstancePayload) => importInstance(payload),
     onSuccess: () => {
       resetInstanceScopedCaches(queryClient);
+      invalidateInstanceConnectivity(queryClient);
       refreshRuntimeContext(queryClient);
       toast.success(t("instance.toast.tokenImported"));
     },
@@ -124,6 +162,7 @@ export function useUpdateInstance(name: string) {
     onSuccess: () => {
       invalidateInstanceScopedCaches(queryClient);
       queryClient.invalidateQueries({ queryKey: ["instance"] });
+      invalidateInstanceConnectivity(queryClient);
       refreshRuntimeContext(queryClient);
       toast.success(t("instance.toast.updated"));
     },
@@ -144,6 +183,7 @@ export function useDeleteInstance() {
     mutationFn: (name: string) => deleteInstance(name),
     onSuccess: () => {
       invalidateInstanceScopedCaches(queryClient);
+      invalidateInstanceConnectivity(queryClient);
       refreshRuntimeContext(queryClient);
       toast.success(t("instance.toast.deleted"));
     },

package/dist/dashboard-runtime/dashboard/src/hooks/use-memory-store-scopes.ts

@@ -48,6 +48,7 @@ export function useMemoryStoreScopes(
 export function useAllMemoryStoreScopes(
   memoryStoreName: string,
   scope: MemoryScope | null,
+  options: { enabled?: boolean } = {},
 ) {
   const { context, ready } = useRuntimeContext();
   const effective: MemoryScope = {
@@ -66,7 +67,7 @@ export function useAllMemoryStoreScopes(
       "all",
     ],
     queryFn: () => listAllMemoryStoreScopes(memoryStoreName, effective),
-    enabled: ready && !!memoryStoreName,
+    enabled: options.enabled !== false && ready && !!memoryStoreName,
     staleTime: 30 * 1000,
   });
 }

package/dist/dashboard-runtime/dashboard/src/hooks/use-qa-chat.ts

@@ -5,6 +5,11 @@ import { useCallback, useEffect, useRef, useState } from "react";
 import { useI18n } from "@/i18n/i18n-context";
 
 import { streamChat } from "@/services/llm-chat";
+import {
+  loadBrowserFileMemory,
+  searchBrowserFileMemory,
+} from "@/lib/browser-file-memory";
+import { FILEMEM_DEFAULT_RUN_ID } from "@/lib/memory-storage-mode";
 import { newId } from "@/lib/random-id";
 import { devFlag } from "@/lib/dev-flags";
 import {
@@ -24,7 +29,29 @@ import type { ChatMessage, ChatRequestBody, ChatRole } from "@/types/llm-chat";
  */
 type StreamPatch = { content?: string; reasoning?: string };
 
+/** Remove a curation state that never received a terminal server event. */
+export function settlePendingMemorySave(
+  messages: ChatMessage[],
+  assistantId: string,
+): ChatMessage[] {
+  let changed = false;
+  const settled = messages.map((message) => {
+    if (message.id !== assistantId || message.memorySaveStatus !== "saving") {
+      return message;
+    }
+    changed = true;
+    const next = { ...message };
+    delete next.memorySaveStatus;
+    delete next.memorySavePath;
+    delete next.memorySaveCount;
+    delete next.memorySaveError;
+    return next;
+  });
+  return changed ? settled : messages;
+}
+
 export interface UseQaChatOptions {
+  dataScopeKey: string;
   activeInstance: string | null;
   providerId: string;
   model: string;
@@ -41,6 +68,17 @@ export interface UseQaChatOptions {
   onPersist?: (messages: ChatMessage[]) => void;
 }
 
+function normalizeMemoryForRequest(
+  memory: ChatRequestBody["memory"],
+): ChatRequestBody["memory"] {
+  if (memory?.storageMode !== "filemem") return memory;
+  return {
+    ...memory,
+    scope: { ...memory.scope, runId: FILEMEM_DEFAULT_RUN_ID },
+    retrievalMode: "local",
+  };
+}
+
 /**
  * Compose the wire body sent to `/api/v1/llm/chat` for one turn. Pulled out
  * of `_runAssistantTurn` so it can be unit-tested without spinning up React
@@ -62,6 +100,13 @@ export function buildChatRequestBody(
   historyToSend: Array<{ role: ChatRole; content: string }>,
   turnId: string,
 ): ChatRequestBody {
+  const normalizedMemory = normalizeMemoryForRequest(opts.memory);
+  const memory = normalizedMemory
+    ? {
+        ...normalizedMemory,
+        turnId,
+      }
+    : undefined;
   return {
     activeInstance: opts.activeInstance,
     providerId: opts.providerId,
@@ -70,10 +115,100 @@ export function buildChatRequestBody(
     systemPrompt: opts.systemPrompt,
     temperature: opts.temperature,
     rag: opts.rag,
-    ...(opts.memory ? { memory: { ...opts.memory, turnId } } : {}),
+    ...(memory ? { memory } : {}),
   };
 }
 
+type PrepareChatRequestOptions = Pick<
+  UseQaChatOptions,
+  | "dataScopeKey"
+  | "activeInstance"
+  | "providerId"
+  | "model"
+  | "systemPrompt"
+  | "temperature"
+  | "rag"
+  | "memory"
+>;
+
+/** Add browser-only file-memory evidence immediately before opening the SSE. */
+export async function prepareChatRequestBody(
+  opts: PrepareChatRequestOptions,
+  historyToSend: Array<{ role: ChatRole; content: string }>,
+  turnId: string,
+  deps: {
+    loadFileMemory?: typeof loadBrowserFileMemory;
+    searchFileMemory?: typeof searchBrowserFileMemory;
+  } = {},
+): Promise<ChatRequestBody> {
+  const memory = normalizeMemoryForRequest(opts.memory);
+  if (
+    !memory ||
+    (memory.retrievalMode !== "local" && memory.storageMode !== "filemem")
+  ) {
+    return buildChatRequestBody(opts, historyToSend, turnId);
+  }
+  const loadFileMemory = deps.loadFileMemory ?? loadBrowserFileMemory;
+  const searchFileMemory = deps.searchFileMemory ?? searchBrowserFileMemory;
+  const loaded = await loadFileMemory({
+    dataScopeKey: opts.dataScopeKey,
+    memoryStoreName: memory.memoryStoreName,
+    scope: memory.scope,
+  });
+  const lastUser = [...historyToSend]
+    .reverse()
+    .find((message) => message.role === "user");
+  const search = searchFileMemory({
+    key: loaded.key,
+    query: lastUser?.content ?? "",
+    topK: memory.topK ?? 5,
+  });
+  const files = loaded.files
+    .filter(
+      (file) =>
+        file.rel.length > 0 &&
+        file.rel.length <= 512 &&
+        Number.isSafeInteger(file.size) &&
+        file.size >= 0,
+    )
+    .slice(0, 300);
+  const hits = search.results
+    .filter(
+      (hit) =>
+        hit.text.length > 0 &&
+        hit.source.length > 0 &&
+        hit.source.length <= 512 &&
+        Number.isFinite(hit.score),
+    )
+    .slice(0, 50)
+    .map((hit) => ({
+      ...hit,
+      text: hit.text.slice(0, 4_000),
+      score: Math.max(0, Math.min(1, hit.score)),
+    }));
+  const cacheSummary = {
+    ...loaded.cache,
+    ...(loaded.cache.error
+      ? { error: loaded.cache.error.slice(0, 4_000) }
+      : {}),
+  };
+  return buildChatRequestBody(
+    {
+      ...opts,
+      memory: {
+        ...memory,
+        fileContext: {
+          files,
+          hits,
+          cache: cacheSummary,
+        },
+      },
+    },
+    historyToSend,
+    turnId,
+  );
+}
+
 export interface UseQaChatResult {
   messages: ChatMessage[];
   isStreaming: boolean;
@@ -144,19 +279,19 @@ export function useQaChat(options: UseQaChatOptions): UseQaChatResult {
     if (pending.size === 0) return;
     const snapshot = new Map(pending);
     pending.clear();
-    setMessages((prev) =>
-      prev.map((m) => {
-        const patch = snapshot.get(m.id);
-        if (!patch) return m;
-        return {
-          ...m,
-          ...(patch.content ? { content: m.content + patch.content } : null),
-          ...(patch.reasoning
-            ? { reasoning: (m.reasoning ?? "") + patch.reasoning }
-            : null),
-        };
-      }),
-    );
+    const nextMessages = messagesRef.current.map((m) => {
+      const patch = snapshot.get(m.id);
+      if (!patch) return m;
+      return {
+        ...m,
+        ...(patch.content ? { content: m.content + patch.content } : null),
+        ...(patch.reasoning
+          ? { reasoning: (m.reasoning ?? "") + patch.reasoning }
+          : null),
+      };
+    });
+    messagesRef.current = nextMessages;
+    setMessages(nextMessages);
   }, []);
 
   const scheduleFlush = useCallback(() => {
@@ -239,13 +374,15 @@ export function useQaChat(options: UseQaChatOptions): UseQaChatResult {
       const reasoningCompletedRef = { current: false };
 
       const updateAssistant = (patch: Partial<ChatMessage>) => {
-        setMessages((prev) =>
-          prev.map((m) => (m.id === assistantId ? { ...m, ...patch } : m)),
+        const nextMessages = messagesRef.current.map((m) =>
+          m.id === assistantId ? { ...m, ...patch } : m,
         );
+        messagesRef.current = nextMessages;
+        setMessages(nextMessages);
       };
 
       try {
-        const body = buildChatRequestBody(opts, historyToSend, turnId);
+        const body = await prepareChatRequestBody(opts, historyToSend, turnId);
 
         if (devFlag("logChatRequest")) {
           // Diagnostic surface for the cross-session bleed investigation.
@@ -293,15 +430,35 @@ export function useQaChat(options: UseQaChatOptions): UseQaChatResult {
             // 「想看为什么没召回」时 message 上没有信号可查。
             updateAssistant({ memoryHits: event.hits });
           } else if (event.type === "memory.files") {
-            // 文件记忆模式专属：把本轮同步的镜像目录、文件树与同步统计
-            // 落到 assistant message 上，供气泡展示「本轮文件记忆」摘要。
+            // 文件记忆模式专属：把浏览器标签页中的文件树与缓存统计落到
+            // assistant message 上，供气泡展示「本轮文件记忆」摘要。
             updateAssistant({
-              memoryFilesScopeDir: event.scopeDir,
               memoryFiles: event.files,
-              memoryFilesSync: event.sync,
+              memoryFilesCache: event.cache,
+              memoryFilesStoreName: event.memoryStoreName,
+              memoryFilesWritable: event.writable,
+              memoryFilesScope: event.scope,
+            });
+          } else if (event.type === "memory.save.start") {
+            updateAssistant({
+              memorySaveStatus: "saving",
+              memorySavePath: undefined,
+              memorySaveCount: undefined,
+              memorySaveError: undefined,
+            });
+          } else if (event.type === "memory.save.done") {
+            updateAssistant({
+              memorySaveStatus: event.status,
+              memorySavePath: event.path,
+              memorySaveCount: event.count,
+              memorySaveError: undefined,
             });
           } else if (event.type === "memory.save.skipped") {
-            // 写回失败不打断对话流，留给 logger 处理。
+            updateAssistant({
+              memorySaveStatus: "error",
+              memorySaveError: event.reason,
+            });
+            // 写回失败不打断对话流，同时保留控制台诊断。
             console.warn("[chat] memory.save.skipped:", event.reason);
           } else if (event.type === "reasoning.delta") {
             const buf = pendingDeltasRef.current.get(assistantId) ?? {};
@@ -369,6 +526,14 @@ export function useQaChat(options: UseQaChatOptions): UseQaChatResult {
           updateAssistant({ status: "done", ...closeReasoning });
         }
       } finally {
+        cancelScheduledFlush();
+        flushDeltas();
+        const settledMessages = settlePendingMemorySave(
+          messagesRef.current,
+          assistantId,
+        );
+        messagesRef.current = settledMessages;
+        setMessages(settledMessages);
         setIsStreaming(false);
         abortRef.current = null;
         // Flush the latest snapshot to the persist handler.
@@ -376,7 +541,7 @@ export function useQaChat(options: UseQaChatOptions): UseQaChatResult {
         // calling side effects during React's render phase.
         const persist = onPersistRef.current;
         if (persist) {
-          persist(messagesRef.current);
+          persist(settledMessages);
         }
       }
     },