@tablestore/tablestore-agent-cli 0.3.1 → 0.4.0

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

@@ -0,0 +1,295 @@
+import type { NextRequest } from "next/server";
+
+import type { StandardResponse } from "@tablestore/tablestore-agent-sdk";
+
+import {
+  errorResponse,
+  forwardResponse,
+  handleApiError,
+  requireClients,
+  successResponse,
+} from "@/lib/server/api-helpers";
+
+import {
+  assertWikiSourceContent,
+  hasCallerWikiId,
+  readExactScopeFromQuery,
+  readOptionalNextToken,
+  readOptionalQueryLimit,
+  readWikiJsonBody,
+  sanitizeWikiSourceErrorResponse,
+  toPublicWikiSource,
+  toWikiRawItemPath,
+  type PublicWikiSource,
+} from "../_helpers";
+import { toAgentWikiScope } from "../../_scope";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+const LIST_PAGE_LIMIT = 100;
+const MAX_BATCH_SOURCES = 20;
+const BATCH_CONCURRENCY = 1;
+
+interface RouteContext {
+  params: Promise<{ store: string }>;
+}
+
+interface ValidatedSource {
+  path: string;
+  physicalPath: string;
+  content: string;
+}
+
+interface BatchSourceError {
+  code: string;
+  message: string;
+  httpStatus?: number;
+  requestId?: string;
+}
+
+type BatchSourceResult =
+  | { ok: true; path: string; source: PublicWikiSource }
+  | { ok: false; path: string; error: BatchSourceError };
+
+const FALLBACK_ERROR_STATUS: Record<string, number> = {
+  BAD_REQUEST: 400,
+  INVALID_PARAMETER: 400,
+  VALIDATION_ERROR: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  CONFLICT: 409,
+  LOCK_CONFLICT: 409,
+  PATH_EXISTS: 409,
+  QUOTA_EXCEEDED: 409,
+  READ_ONLY_STORE: 409,
+  PAYLOAD_TOO_LARGE: 413,
+  FLOW_CONTROL: 429,
+  QUOTA_EXHAUSTED: 429,
+  INTERNAL_SERVER_ERROR: 500,
+  NETWORK_ERROR: 503,
+  SERVICE_UNAVAILABLE: 503,
+};
+
+function invalidRequest(message: string) {
+  return errorResponse("BAD_REQUEST", message, 400);
+}
+
+function responseRecord(response: StandardResponse): Record<string, unknown> {
+  if (
+    !response.data ||
+    typeof response.data !== "object" ||
+    Array.isArray(response.data)
+  ) {
+    throw new Error("Invalid Memory Item response");
+  }
+  return response.data as Record<string, unknown>;
+}
+
+function readNextToken(data: Record<string, unknown>): string | undefined {
+  const token = data.nextToken;
+  if (token === undefined) return undefined;
+  if (typeof token !== "string" || !token) {
+    throw new Error("Invalid Memory Item pagination response");
+  }
+  return token;
+}
+
+function batchError(response: StandardResponse): BatchSourceError {
+  const safeResponse = sanitizeWikiSourceErrorResponse(response);
+  const details =
+    safeResponse.details &&
+    typeof safeResponse.details === "object" &&
+    !Array.isArray(safeResponse.details)
+      ? (safeResponse.details as Record<string, unknown>)
+      : {};
+  const code =
+    typeof details.upstreamCode === "string"
+      ? details.upstreamCode
+      : safeResponse.code;
+  const httpStatus =
+    typeof details.upstreamStatus === "number" &&
+    Number.isInteger(details.upstreamStatus)
+      ? details.upstreamStatus
+      : FALLBACK_ERROR_STATUS[safeResponse.code];
+  const requestId =
+    typeof details.upstreamRequestId === "string"
+      ? details.upstreamRequestId
+      : safeResponse.requestId || undefined;
+  return {
+    code,
+    message: safeResponse.message,
+    ...(httpStatus !== undefined ? { httpStatus } : {}),
+    ...(requestId ? { requestId } : {}),
+  };
+}
+
+function malformedBatchError(response: StandardResponse): BatchSourceError {
+  return {
+    code: "INTERNAL_SERVER_ERROR",
+    message: "Invalid Memory Item response",
+    ...(response.requestId ? { requestId: response.requestId } : {}),
+    httpStatus: 500,
+  };
+}
+
+function validateBatchSources(rawSources: unknown): ValidatedSource[] | null {
+  if (
+    !Array.isArray(rawSources) ||
+    rawSources.length < 1 ||
+    rawSources.length > MAX_BATCH_SOURCES
+  ) {
+    return null;
+  }
+
+  try {
+    return rawSources.map((rawSource) => {
+      if (
+        !rawSource ||
+        typeof rawSource !== "object" ||
+        Array.isArray(rawSource)
+      ) {
+        throw new Error("Invalid source entry");
+      }
+      const source = rawSource as Record<string, unknown>;
+      const originalPath = source.path;
+      if (typeof originalPath !== "string") {
+        throw new Error("Invalid source path");
+      }
+      const physicalPath = toWikiRawItemPath(originalPath);
+      return {
+        path: originalPath,
+        physicalPath,
+        content: assertWikiSourceContent(source.content),
+      };
+    });
+  } catch {
+    return null;
+  }
+}
+
+export async function GET(request: NextRequest, context: RouteContext) {
+  try {
+    const { store } = await context.params;
+    const auth = requireClients(request);
+    if (!("memory" in auth)) return auth;
+
+    const params = new URL(request.url).searchParams;
+    const scope = readExactScopeFromQuery(params);
+    const limit = readOptionalQueryLimit(params.get("limit"));
+    const nextToken = readOptionalNextToken(params.get("nextToken"));
+    if (!scope || hasCallerWikiId(request) || !limit.ok || !nextToken.ok) {
+      return invalidRequest(
+        "An exact scope without legacy Wiki identity is required",
+      );
+    }
+
+    const pathPrefix = "/.wiki/raw/";
+    request.signal.throwIfAborted();
+    const response = await auth.memory.listItems(
+      {
+        memoryStoreName: store,
+        scope: toAgentWikiScope(scope),
+        pathPrefix,
+        depth: 0,
+        view: "basic",
+        limit: limit.value ?? LIST_PAGE_LIMIT,
+        ...(nextToken.value !== undefined
+          ? { nextToken: nextToken.value }
+          : {}),
+      },
+      request.signal,
+    );
+    if (response.code !== "SUCCESS") {
+      return forwardResponse(sanitizeWikiSourceErrorResponse(response));
+    }
+
+    const data = responseRecord(response);
+    if (!Array.isArray(data.items)) {
+      throw new Error("Invalid Memory Item list response");
+    }
+    const sources = data.items.map((rawItem) => toPublicWikiSource(rawItem));
+    const responseNextToken = readNextToken(data);
+    return successResponse({
+      sources,
+      ...(responseNextToken !== undefined
+        ? { nextToken: responseNextToken }
+        : {}),
+    });
+  } catch (error) {
+    return handleApiError(error);
+  }
+}
+
+export async function POST(request: NextRequest, context: RouteContext) {
+  try {
+    const { store } = await context.params;
+    const auth = requireClients(request);
+    if (!("memory" in auth)) return auth;
+
+    const body = await readWikiJsonBody(request);
+    if (!body || hasCallerWikiId(request, body)) {
+      return invalidRequest(
+        "Request requires an exact scope without legacy Wiki identity",
+      );
+    }
+    const sources = validateBatchSources(body.sources);
+    if (!sources) {
+      return invalidRequest("Request requires 1..20 valid sources");
+    }
+
+    const results = new Array<BatchSourceResult>(sources.length);
+    let nextIndex = 0;
+    const worker = async (): Promise<void> => {
+      while (true) {
+        request.signal.throwIfAborted();
+        const index = nextIndex;
+        if (index >= sources.length) return;
+        nextIndex += 1;
+        const source = sources[index]!;
+        const response = await auth.memory.addItem(
+          {
+            memoryStoreName: store,
+            scope: toAgentWikiScope(body.scope),
+            path: source.physicalPath,
+            content: source.content,
+            view: "full",
+          },
+          request.signal,
+        );
+        request.signal.throwIfAborted();
+        if (response.code !== "SUCCESS") {
+          results[index] = {
+            ok: false,
+            path: source.path,
+            error: batchError(response),
+          };
+          continue;
+        }
+        try {
+          results[index] = {
+            ok: true,
+            path: source.path,
+            source: toPublicWikiSource(response.data),
+          };
+        } catch {
+          results[index] = {
+            ok: false,
+            path: source.path,
+            error: malformedBatchError(response),
+          };
+        }
+      }
+    };
+
+    await Promise.all(
+      Array.from({ length: Math.min(BATCH_CONCURRENCY, sources.length) }, () =>
+        worker(),
+      ),
+    );
+    return successResponse({ results });
+  } catch (error) {
+    return handleApiError(error);
+  }
+}

package/dist/dashboard-runtime/dashboard/src/components/api-keys/custom-policy-editor.tsx

@@ -234,7 +234,8 @@ function RuleRow({
     if (rule.scope.appId) parts.push(`app:${rule.scope.appId}`);
     if (rule.scope.tenantId) parts.push(`tenant:${rule.scope.tenantId}`);
     if (rule.scope.agentId) parts.push(`agent:${rule.scope.agentId}`);
-    if (rule.scope.runId) parts.push(`run:${rule.scope.runId}`);
+    if (rule.scope.runId)
+      parts.push(`${t("memory.scopeField.run")}:${rule.scope.runId}`);
     if (parts.length > 0) scopeLabel = ` (${parts.join(", ")})`;
   }
 

package/dist/dashboard-runtime/dashboard/src/components/api-keys/permission-rule-dialog.tsx

@@ -22,7 +22,11 @@ import {
   SelectTrigger,
   SelectValue,
 } from "@/components/ui/select";
-import { useI18n, type MessageKey } from "@/i18n/i18n-context";
+import {
+  useI18n,
+  type MessageKey,
+  type TranslateFn,
+} from "@/i18n/i18n-context";
 import { useKnowledgeBases } from "@/hooks/use-knowledge-bases";
 import { useMemoryStores } from "@/hooks/use-memory-stores";
 import { listMemoryStoreScopesUnfiltered } from "@/services/memory";
@@ -74,17 +78,20 @@ function scopeKey(s: {
   );
 }
 
-function formatScope(s: {
-  appId?: string;
-  tenantId?: string;
-  agentId?: string;
-  runId?: string;
-}): string {
+function formatScope(
+  s: {
+    appId?: string;
+    tenantId?: string;
+    agentId?: string;
+    runId?: string;
+  },
+  t: TranslateFn,
+): string {
   const parts: string[] = [];
   if (s.appId) parts.push(`app:${s.appId}`);
   if (s.tenantId) parts.push(`tenant:${s.tenantId}`);
   if (s.agentId) parts.push(`agent:${s.agentId}`);
-  if (s.runId) parts.push(`run:${s.runId}`);
+  if (s.runId) parts.push(`${t("memory.scopeField.run")}:${s.runId}`);
   return parts.join(", ");
 }
 
@@ -349,7 +356,7 @@ export function PermissionRuleDialog({
                                   }}
                                 />
                                 <span className="text-xs font-mono truncate">
-                                  {formatScope(s)}
+                                  {formatScope(s, t)}
                                 </span>
                               </label>
                             );
@@ -409,7 +416,7 @@ export function PermissionRuleDialog({
                       </div>
                       <div className="space-y-1">
                         <Label className="text-[11px] text-muted-foreground">
-                          Run ID
+                          {t("apiKeys.rule.sessionId")}
                         </Label>
                         <Input
                           value={scope.runId ?? ""}

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

@@ -14,6 +14,7 @@ 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 {
@@ -62,6 +63,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 +75,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 +99,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 +118,93 @@ 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 (
+    memory?.storageMode === "ots" ||
+    memory?.storageMode === "file+ots" ||
+    memory?.storageMode === "filemem"
+  );
+}
+
+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 +271,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 +341,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 +386,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 +419,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 +434,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 +515,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();