@tablestore/tablestore-agent-cli 0.3.1 → 0.4.1

package/dist/dashboard-runtime/dashboard/src/components/chat/chat-config-context.tsx

@@ -14,10 +14,12 @@ import type {
   ChatSessionConfig,
   ChatSessionMount,
 } from "@/hooks/use-chat-history";
+import type { ChatRequestBody } from "@/types/llm-chat";
 import { assembleRetrievalConfiguration } from "@/components/retrieval/assemble-retrieval-configuration";
 import { newId } from "@/lib/random-id";
 import {
   FILEMEM_DEFAULT_RUN_ID,
+  isKnownStorageMode,
   normalizeMemoryRunId,
   type StorageMode,
 } from "@/lib/memory-storage-mode";
@@ -62,6 +64,8 @@ export interface ChatConfigState {
   retrieval: ChatRetrievalConfig;
   mounts: MountItem[];
   memory?: ChatMemoryBinding;
+  wikiEnabled: boolean;
+  wikiTopK: number;
 }
 
 /** Default aggregate topK applied when a session is first created. Mirrors
@@ -72,6 +76,7 @@ export const DEFAULT_AGGREGATE_TOP_K = 20;
  *  cap so single-KB sessions get the full result set without truncation;
  *  multi-KB sessions still benefit from the post-merge global rerank. */
 export const DEFAULT_PER_KB_TOP_K = 20;
+export const DEFAULT_WIKI_TOP_K = 3;
 
 /**
  * Default unified retrieval parameters for a fresh session. Mirrors the
@@ -95,6 +100,8 @@ export const INITIAL_STATE: ChatConfigState = {
   perKbTopK: DEFAULT_PER_KB_TOP_K,
   retrieval: DEFAULT_RETRIEVAL,
   mounts: [],
+  wikiEnabled: false,
+  wikiTopK: DEFAULT_WIKI_TOP_K,
 };
 
 type Action =
@@ -112,9 +119,89 @@ type Action =
   | { type: "REORDER_MOUNTS"; ids: string[] }
   | { type: "SET_MEMORY"; binding: Omit<ChatMemoryBinding, "id"> | undefined }
   | { type: "UPDATE_MEMORY"; patch: ChatMemoryPatch }
+  | { type: "SET_WIKI_ENABLED"; enabled: boolean }
+  | { type: "SET_WIKI_TOP_K"; topK: number }
   | { type: "HYDRATE"; state: Partial<ChatConfigState> }
   | { type: "RESET" };
 
+function memoryBindingIdentity(
+  memory: ChatMemoryBinding | undefined,
+): string | undefined {
+  if (!memory) return undefined;
+  return JSON.stringify([
+    memory.memoryStoreName,
+    memory.storageMode ?? null,
+    memory.scope.appId,
+    memory.scope.tenantId,
+    memory.scope.agentId,
+    memory.scope.runId,
+  ]);
+}
+
+function normalizeMemoryBinding(
+  binding: Omit<ChatMemoryBinding, "id">,
+  id: string,
+): ChatMemoryBinding {
+  return {
+    id,
+    ...binding,
+    scope: {
+      ...binding.scope,
+      runId: normalizeMemoryRunId(binding.storageMode, binding.scope.runId),
+    },
+  };
+}
+
+function isExactMemoryBinding(memory: ChatMemoryBinding | undefined): boolean {
+  if (!memory || !memory.memoryStoreName.trim()) return false;
+  return Object.values(memory.scope).every((value) => {
+    const normalized = value.trim();
+    return normalized.length > 0 && normalized !== "*";
+  });
+}
+
+function hasExplicitKnownStorageMode(
+  memory: ChatMemoryBinding | undefined,
+): boolean {
+  return isKnownStorageMode(memory?.storageMode);
+}
+
+export function isWikiEligibleMemoryBinding(
+  memory: ChatMemoryBinding | undefined,
+): boolean {
+  return hasExplicitKnownStorageMode(memory) && isExactMemoryBinding(memory);
+}
+
+function sanitizeWikiTopK(raw: unknown): number {
+  return typeof raw === "number" &&
+    Number.isInteger(raw) &&
+    raw >= 1 &&
+    raw <= 10
+    ? raw
+    : DEFAULT_WIKI_TOP_K;
+}
+
+const HYDRATABLE_BASE_KEYS = [
+  "providerId",
+  "model",
+  "systemPrompt",
+  "temperature",
+  "aggregateTopK",
+  "perKbTopK",
+  "retrieval",
+  "mounts",
+] as const satisfies ReadonlyArray<keyof ChatConfigState>;
+
+function pickHydratableBaseState(
+  state: Partial<ChatConfigState>,
+): Partial<ChatConfigState> {
+  return Object.fromEntries(
+    HYDRATABLE_BASE_KEYS.filter((key) =>
+      Object.prototype.hasOwnProperty.call(state, key),
+    ).map((key) => [key, state[key]]),
+  ) as Partial<ChatConfigState>;
+}
+
 export function reducer(
   state: ChatConfigState,
   action: Action,
@@ -181,40 +268,66 @@ export function reducer(
       return { ...state, mounts: reordered };
     }
     case "HYDRATE": {
-      const memory = action.state.memory;
+      const rawState = action.state;
+      const { memory, wikiEnabled, wikiTopK } = rawState;
+      const hydratedState = pickHydratableBaseState(rawState);
+      const hasHydratedMemory = Object.prototype.hasOwnProperty.call(
+        rawState,
+        "memory",
+      );
+      if (!hasHydratedMemory) {
+        const requestedWikiEnabled = Object.prototype.hasOwnProperty.call(
+          rawState,
+          "wikiEnabled",
+        )
+          ? wikiEnabled === true
+          : state.wikiEnabled;
+        return {
+          ...state,
+          ...hydratedState,
+          wikiEnabled:
+            requestedWikiEnabled && isWikiEligibleMemoryBinding(state.memory),
+          ...(Object.prototype.hasOwnProperty.call(rawState, "wikiTopK")
+            ? { wikiTopK: sanitizeWikiTopK(wikiTopK) }
+            : {}),
+        };
+      }
+      if (!memory) {
+        return {
+          ...state,
+          ...hydratedState,
+          memory: undefined,
+          wikiEnabled: false,
+          wikiTopK: sanitizeWikiTopK(wikiTopK),
+        };
+      }
+      const normalizedMemory = normalizeMemoryBinding(memory, memory.id);
       return {
         ...state,
-        ...action.state,
-        ...(memory
-          ? {
-              memory: {
-                ...memory,
-                scope: {
-                  ...memory.scope,
-                  runId: normalizeMemoryRunId(
-                    memory.storageMode,
-                    memory.scope.runId,
-                  ),
-                },
-              },
-            }
-          : {}),
+        ...hydratedState,
+        memory: normalizedMemory,
+        wikiEnabled:
+          wikiEnabled === true && isWikiEligibleMemoryBinding(normalizedMemory),
+        wikiTopK: sanitizeWikiTopK(wikiTopK),
       };
     }
     // SET_MEMORY 同一绑定的 id 保持稳定；只有从无到有时才铸新 id，避免不必要的 React key 抖动。
     case "SET_MEMORY": {
-      if (!action.binding) return { ...state, memory: undefined };
-      const runId = normalizeMemoryRunId(
-        action.binding.storageMode,
-        action.binding.scope.runId,
+      if (!action.binding) {
+        return { ...state, memory: undefined, wikiEnabled: false };
+      }
+      const memory = normalizeMemoryBinding(
+        action.binding,
+        state.memory?.id ?? newId("memory"),
       );
       return {
         ...state,
-        memory: {
-          id: state.memory?.id ?? newId("memory"),
-          ...action.binding,
-          scope: { ...action.binding.scope, runId },
-        },
+        memory,
+        wikiEnabled:
+          isWikiEligibleMemoryBinding(memory) &&
+          memoryBindingIdentity(state.memory) === memoryBindingIdentity(memory)
+            ? state.wikiEnabled
+            : false,
       };
     }
     case "UPDATE_MEMORY": {
@@ -225,17 +338,28 @@ export function reducer(
         ...rest,
         scope: { ...state.memory.scope, ...(patchScope ?? {}) },
       };
+      const normalizedMemory = normalizeMemoryBinding(memory, memory.id);
       return {
         ...state,
-        memory: {
-          ...memory,
-          scope: {
-            ...memory.scope,
-            runId: normalizeMemoryRunId(memory.storageMode, memory.scope.runId),
-          },
-        },
+        memory: normalizedMemory,
+        wikiEnabled:
+          isWikiEligibleMemoryBinding(normalizedMemory) &&
+          memoryBindingIdentity(state.memory) ===
+            memoryBindingIdentity(normalizedMemory)
+            ? state.wikiEnabled
+            : false,
       };
     }
+    case "SET_WIKI_ENABLED":
+      return {
+        ...state,
+        wikiEnabled:
+          action.enabled && isWikiEligibleMemoryBinding(state.memory),
+      };
+    case "SET_WIKI_TOP_K":
+      return sanitizeWikiTopK(action.topK) === action.topK
+        ? { ...state, wikiTopK: action.topK }
+        : state;
     case "RESET":
       return INITIAL_STATE;
     default:
@@ -259,6 +383,8 @@ export interface ChatConfigContextValue extends ChatConfigState {
   reorderMounts(ids: string[]): void;
   setMemory(binding: Omit<ChatMemoryBinding, "id"> | undefined): void;
   updateMemory(patch: ChatMemoryPatch): void;
+  setWikiEnabled(enabled: boolean): void;
+  setWikiTopK(topK: number): void;
   hydrate(state: Partial<ChatConfigState>): void;
   reset(): void;
   /** Serialize the current config for persistence into a chat session. */
@@ -290,6 +416,9 @@ export function ChatConfigProvider({ children }: { children: ReactNode }) {
       reorderMounts: (ids) => dispatch({ type: "REORDER_MOUNTS", ids }),
       setMemory: (b) => dispatch({ type: "SET_MEMORY", binding: b }),
       updateMemory: (p) => dispatch({ type: "UPDATE_MEMORY", patch: p }),
+      setWikiEnabled: (enabled) =>
+        dispatch({ type: "SET_WIKI_ENABLED", enabled }),
+      setWikiTopK: (topK) => dispatch({ type: "SET_WIKI_TOP_K", topK }),
       hydrate: (s) => dispatch({ type: "HYDRATE", state: s }),
       reset: () => dispatch({ type: "RESET" }),
       toSessionConfig: () => ({
@@ -302,6 +431,9 @@ export function ChatConfigProvider({ children }: { children: ReactNode }) {
         retrieval: state.retrieval,
         mounts: state.mounts,
         memory: state.memory,
+        ...(state.wikiEnabled && isWikiEligibleMemoryBinding(state.memory)
+          ? { wiki: { enabled: true as const, topK: state.wikiTopK } }
+          : {}),
       }),
     }),
     [state],
@@ -380,6 +512,20 @@ export function buildMemoryFromBinding(state: ChatConfigState) {
   };
 }
 
+export function buildWikiFromBinding(
+  state: ChatConfigState,
+): ChatRequestBody["wiki"] | undefined {
+  if (!state.wikiEnabled || !isWikiEligibleMemoryBinding(state.memory)) {
+    return undefined;
+  }
+  const memory = state.memory as ChatMemoryBinding;
+  return {
+    memoryStoreName: memory.memoryStoreName,
+    scope: memory.scope,
+    topK: state.wikiTopK,
+  };
+}
+
 /** Hook shortcut so downstream components don't have to re-derive the rag. */
 export function useChatRag() {
   const cfg = useChatConfig();

package/dist/dashboard-runtime/dashboard/src/components/chat/chat-scope-entry-hydrator.tsx

@@ -0,0 +1,116 @@
+"use client";
+
+import { useEffect, useRef } from "react";
+import { useSearchParams } from "next/navigation";
+
+import { useChatConfig } from "@/components/chat/chat-config-context";
+import { useWiki } from "@/hooks/use-wikis";
+import {
+  decideChatScopeHydration,
+  parseChatScopeEntry,
+  type ChatScopeEntry,
+} from "@/lib/chat-scope-entry";
+import { resolveRetrievalMode } from "@/lib/memory-storage-mode";
+
+export interface ChatScopeEntryHydratorProps {
+  activeSessionId: string | null;
+  messageCount: number;
+  activeInstanceReady: boolean;
+  projectIdentity: string;
+}
+
+export function ChatScopeEntryHydrator(props: ChatScopeEntryHydratorProps) {
+  const searchParams = useSearchParams();
+  const entry = parseChatScopeEntry(
+    new URLSearchParams(searchParams.toString()),
+  );
+  const latestChatRef = useRef({
+    activeSessionId: props.activeSessionId,
+    messageCount: props.messageCount,
+  });
+  latestChatRef.current = {
+    activeSessionId: props.activeSessionId,
+    messageCount: props.messageCount,
+  };
+  const identity = JSON.stringify([
+    props.projectIdentity,
+    entry
+      ? [
+          entry.memoryStoreName,
+          entry.storageMode,
+          entry.scope.appId,
+          entry.scope.tenantId,
+          entry.scope.agentId,
+          entry.scope.runId,
+          entry.wiki,
+        ]
+      : null,
+  ]);
+  const handledRef = useRef({ identity, handled: false });
+  if (handledRef.current.identity !== identity) {
+    handledRef.current = { identity, handled: false };
+  }
+
+  if (!props.activeInstanceReady || !entry) return null;
+  return (
+    <ReadyChatScopeEntryHydrator
+      entry={entry}
+      identity={identity}
+      latestChatRef={latestChatRef}
+      handledRef={handledRef}
+    />
+  );
+}
+
+function ReadyChatScopeEntryHydrator({
+  entry,
+  identity,
+  latestChatRef,
+  handledRef,
+}: {
+  entry: ChatScopeEntry;
+  identity: string;
+  latestChatRef: {
+    current: { activeSessionId: string | null; messageCount: number };
+  };
+  handledRef: { current: { identity: string; handled: boolean } };
+}) {
+  const cfg = useChatConfig();
+  const query = useWiki(entry.memoryStoreName, entry.scope);
+
+  useEffect(() => {
+    if (query.status === "pending") return;
+    if (handledRef.current.identity !== identity) return;
+
+    const latestChat = latestChatRef.current;
+    const decision = decideChatScopeHydration({
+      entry,
+      activeSessionId: latestChat.activeSessionId,
+      messageCount: latestChat.messageCount,
+      wikiReady: query.data?.status === "ready",
+      handled: handledRef.current.handled,
+    });
+    handledRef.current.handled = true;
+    if (decision.action === "ignore") return;
+
+    cfg.setMemory({
+      memoryStoreName: entry.memoryStoreName,
+      storageMode: entry.storageMode,
+      scope: entry.scope,
+      autoSave: true,
+      topK: 5,
+      retrievalMode: resolveRetrievalMode(undefined, entry.storageMode),
+    });
+    cfg.setWikiEnabled(decision.enableWiki);
+  }, [
+    cfg,
+    entry,
+    handledRef,
+    identity,
+    latestChatRef,
+    query.data?.status,
+    query.status,
+  ]);
+
+  return null;
+}

package/dist/dashboard-runtime/dashboard/src/components/chat/memory-bind-section.tsx

@@ -27,11 +27,13 @@ import {
 } from "@/components/ui/select";
 import { useChatConfig } from "@/components/chat/chat-config-context";
 import { MemoryFilesDialog } from "@/components/chat/memory-files-dialog";
+import { WikiBindSection } from "@/components/chat/wiki-bind-section";
 import { ScopeCombobox } from "@/components/memory/scope-combobox";
 import { useI18n } from "@/i18n/i18n-context";
 import { cn } from "@/lib/utils";
 import {
   normalizeStorageMode,
+  parseKnownStorageMode,
   resolveRetrievalMode,
   storageModeCapabilities,
   type StorageMode,
@@ -51,7 +53,7 @@ import {
 export function MemoryBindSection() {
   const { t } = useI18n();
   const cfg = useChatConfig();
-  const { data: storesPage, isLoading } = useMemoryStores();
+  const { data: storesPage, isLoading, isSuccess } = useMemoryStores();
   const stores = storesPage?.items ?? [];
   const binding = cfg.memory;
   const topKId = useId();
@@ -59,7 +61,13 @@ export function MemoryBindSection() {
   const boundStore = binding
     ? stores.find((s) => s.memoryStoreName === binding.memoryStoreName)
     : undefined;
-  const storageMode = normalizeStorageMode(boundStore?.storageMode);
+  const boundStoreFound = !!boundStore;
+  const authoritativeStorageMode = parseKnownStorageMode(
+    boundStore?.storageMode,
+  );
+  const storageMode = normalizeStorageMode(
+    boundStore?.storageMode ?? binding?.storageMode,
+  );
   const capabilities = storageModeCapabilities(storageMode);
   const autoSaveAllowed =
     capabilities.structuredAutoSave || capabilities.writableFiles;
@@ -69,11 +77,14 @@ export function MemoryBindSection() {
   // 防止加载态误判。
   const currentMode = binding?.retrievalMode;
   useEffect(() => {
-    if (!binding || isLoading) return;
+    if (!binding || !isSuccess || !boundStore) return;
     const corrected = resolveRetrievalMode(currentMode, storageMode);
+    const nextStorageMode = authoritativeStorageMode ?? undefined;
     const patch = {
       ...(currentMode !== corrected ? { retrievalMode: corrected } : {}),
-      ...(binding.storageMode !== storageMode ? { storageMode } : {}),
+      ...(binding.storageMode !== nextStorageMode
+        ? { storageMode: nextStorageMode }
+        : {}),
     };
     if (Object.keys(patch).length > 0) {
       cfg.updateMemory(patch);
@@ -84,8 +95,10 @@ export function MemoryBindSection() {
     binding?.memoryStoreName,
     binding?.storageMode,
     currentMode,
+    authoritativeStorageMode,
     storageMode,
-    isLoading,
+    isSuccess,
+    boundStoreFound,
   ]);
 
   return (
@@ -131,15 +144,20 @@ export function MemoryBindSection() {
         <MemoryBindEmptyState
           stores={stores}
           isLoading={isLoading}
-          onBind={() =>
+          onBind={() => {
+            const authoritativeStorageMode = parseKnownStorageMode(
+              stores[0]?.storageMode,
+            );
             cfg.setMemory({
               memoryStoreName: stores[0]?.memoryStoreName ?? "",
-              storageMode: normalizeStorageMode(stores[0]?.storageMode),
+              ...(authoritativeStorageMode !== null
+                ? { storageMode: authoritativeStorageMode }
+                : {}),
               scope: { appId: "", tenantId: "", agentId: "", runId: "" },
               autoSave: true,
               topK: 5,
-            })
-          }
+            });
+          }}
         />
       ) : (
         <>
@@ -147,16 +165,17 @@ export function MemoryBindSection() {
             value={binding.memoryStoreName}
             stores={stores}
             onChange={(v) => {
-              const nextMode = normalizeStorageMode(
-                stores.find((store) => store.memoryStoreName === v)
-                  ?.storageMode,
-              );
+              const rawMode = stores.find(
+                (store) => store.memoryStoreName === v,
+              )?.storageMode;
+              const authoritativeStorageMode = parseKnownStorageMode(rawMode);
+              const runtimeStorageMode = normalizeStorageMode(rawMode);
               cfg.updateMemory({
                 memoryStoreName: v,
-                storageMode: nextMode,
+                storageMode: authoritativeStorageMode ?? undefined,
                 retrievalMode: resolveRetrievalMode(
                   binding.retrievalMode,
-                  nextMode,
+                  runtimeStorageMode,
                 ),
               });
             }}
@@ -184,6 +203,7 @@ export function MemoryBindSection() {
             onScopeChange={(patch) => cfg.updateMemory({ scope: patch })}
             onAutoSaveChange={(v) => cfg.updateMemory({ autoSave: v })}
           />
+          <WikiBindSection />
         </>
       )}
     </div>
@@ -448,6 +468,7 @@ function MemoryBindingForm(props: {
     appId?: string;
     tenantId?: string;
     agentId?: string;
+    runId?: string;
   }) => void;
   onAutoSaveChange: (v: boolean) => void;
 }) {
@@ -477,6 +498,7 @@ function MemoryBindingForm(props: {
                 appId: s.appId ?? "",
                 tenantId: s.tenantId ?? "",
                 agentId: s.agentId ?? "",
+                runId: s.runId ?? "",
               })
             }
           />