@tablestore/tablestore-agent-cli 0.2.11 → 0.4.0

package/dist/dashboard-runtime/dashboard/src/lib/wiki-metadata-limits.ts

@@ -0,0 +1,133 @@
+import type {
+  WikiEvidence,
+  WikiRetrievalError,
+  WikiRetrievalGroup,
+} from "@/types/llm-chat";
+
+export const MAX_WIKI_METADATA_ID_CHARS = 256;
+export const MAX_WIKI_METADATA_PATH_CHARS = 1_024;
+export const MAX_WIKI_METADATA_NAME_CHARS = 256;
+export const MAX_WIKI_METADATA_TITLE_CHARS = 512;
+export const MAX_WIKI_METADATA_TYPE_CHARS = 128;
+export const MAX_WIKI_METADATA_DESCRIPTION_CHARS = 2_048;
+export const MAX_WIKI_METADATA_SOURCE_CHARS = 1_024;
+export const MAX_WIKI_ERROR_CODE_CHARS = 128;
+export const MAX_WIKI_ERROR_MESSAGE_CHARS = 1_024;
+export const MAX_WIKI_ERROR_PATH_CHARS = 1_024;
+export const MAX_WIKI_SOURCES = 8;
+export const MAX_WIKI_ERRORS = 4;
+export const MAX_WIKI_EVIDENCE = 6;
+export const MAX_WIKI_GROUPS = 10;
+
+export function normalizeRequiredWikiMetadata(
+  value: unknown,
+): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : undefined;
+}
+
+export function truncateWikiMetadata(
+  value: string,
+  maxCodePoints: number,
+): string {
+  const codePoints = Array.from(value);
+  if (codePoints.length <= maxCodePoints) return value;
+  if (maxCodePoints <= 0) return "";
+  return `${codePoints.slice(0, maxCodePoints - 1).join("")}…`;
+}
+
+export function clampWikiEvidence(value: WikiEvidence): WikiEvidence {
+  return {
+    reference: value.reference,
+    wikiName: truncateWikiMetadata(
+      value.wikiName,
+      MAX_WIKI_METADATA_NAME_CHARS,
+    ),
+    path: truncateWikiMetadata(value.path, MAX_WIKI_METADATA_PATH_CHARS),
+    ...(value.title === undefined
+      ? {}
+      : {
+          title: truncateWikiMetadata(
+            value.title,
+            MAX_WIKI_METADATA_TITLE_CHARS,
+          ),
+        }),
+    ...(value.type === undefined
+      ? {}
+      : {
+          type: truncateWikiMetadata(value.type, MAX_WIKI_METADATA_TYPE_CHARS),
+        }),
+    ...(value.description === undefined
+      ? {}
+      : {
+          description: truncateWikiMetadata(
+            value.description,
+            MAX_WIKI_METADATA_DESCRIPTION_CHARS,
+          ),
+        }),
+    ...(value.score === undefined ? {} : { score: value.score }),
+    ...(value.sources === undefined
+      ? {}
+      : {
+          sources: value.sources
+            .slice(0, MAX_WIKI_SOURCES)
+            .map((source) =>
+              truncateWikiMetadata(source, MAX_WIKI_METADATA_SOURCE_CHARS),
+            ),
+        }),
+    truncated: value.truncated,
+    injectedChars: value.injectedChars,
+  };
+}
+
+export function clampWikiRetrievalError(
+  value: WikiRetrievalError,
+): WikiRetrievalError {
+  return {
+    code: truncateWikiMetadata(value.code, MAX_WIKI_ERROR_CODE_CHARS),
+    message: truncateWikiMetadata(value.message, MAX_WIKI_ERROR_MESSAGE_CHARS),
+    ...(value.requestId === undefined
+      ? {}
+      : {
+          requestId: truncateWikiMetadata(
+            value.requestId,
+            MAX_WIKI_METADATA_ID_CHARS,
+          ),
+        }),
+    ...(value.httpStatus === undefined ? {} : { httpStatus: value.httpStatus }),
+    stage: value.stage,
+    ...(value.path === undefined
+      ? {}
+      : {
+          path: truncateWikiMetadata(value.path, MAX_WIKI_ERROR_PATH_CHARS),
+        }),
+  };
+}
+
+export function clampWikiRetrievalGroup(
+  value: WikiRetrievalGroup,
+): WikiRetrievalGroup {
+  return {
+    wikiName: truncateWikiMetadata(
+      value.wikiName,
+      MAX_WIKI_METADATA_NAME_CHARS,
+    ),
+    pages: value.pages.slice(0, MAX_WIKI_EVIDENCE).map(clampWikiEvidence),
+    ...(value.errors === undefined
+      ? {}
+      : {
+          errors: value.errors
+            .slice(0, MAX_WIKI_ERRORS)
+            .map(clampWikiRetrievalError),
+        }),
+  };
+}
+
+export function clampWikiRetrievalGroups(
+  values: ReadonlyArray<WikiRetrievalGroup>,
+): WikiRetrievalGroup[] {
+  return values
+    .slice(0, MAX_WIKI_GROUPS)
+    .map((group) => clampWikiRetrievalGroup(group));
+}

package/dist/dashboard-runtime/dashboard/src/lib/wiki-page-tree.ts

@@ -0,0 +1,153 @@
+import type { WikiPage } from "@/types/wiki";
+
+export interface WikiTreeSourceFile {
+  rel: string;
+  originalPath: string;
+  size: number;
+}
+
+export interface WikiTreeFile extends WikiTreeSourceFile {
+  type: "file";
+  name: string;
+}
+
+export interface WikiTreeDir {
+  type: "dir";
+  name: string;
+  rel: string;
+  children: WikiTreeNode[];
+}
+
+export type WikiTreeNode = WikiTreeDir | WikiTreeFile;
+
+export interface VisibleWikiTreeRow {
+  node: WikiTreeNode;
+  depth: number;
+}
+
+export function wikiDisplayPath(path: string): string {
+  return path.startsWith("/wiki/")
+    ? path.slice("/wiki/".length)
+    : path.replace(/^\/+/, "");
+}
+
+export function toWikiTreeFile(
+  page: Pick<WikiPage, "path">,
+): WikiTreeSourceFile {
+  return {
+    rel: wikiDisplayPath(page.path),
+    originalPath: page.path,
+    size: 0,
+  };
+}
+
+export function mergeWikiPages(
+  ...groups: ReadonlyArray<readonly WikiPage[]>
+): WikiPage[] {
+  const merged: WikiPage[] = [];
+  const seen = new Set<string>();
+  for (const group of groups) {
+    for (const page of group) {
+      if (seen.has(page.path)) continue;
+      seen.add(page.path);
+      merged.push(page);
+    }
+  }
+  return merged;
+}
+
+function sortChildren(nodes: WikiTreeNode[]): void {
+  nodes.sort((left, right) => {
+    if (left.type !== right.type) return left.type === "dir" ? -1 : 1;
+    return left.name.localeCompare(right.name);
+  });
+  for (const node of nodes) {
+    if (node.type === "dir") sortChildren(node.children);
+  }
+}
+
+export function buildWikiPageTree(pages: readonly WikiPage[]): WikiTreeDir {
+  const root: WikiTreeDir = {
+    type: "dir",
+    name: "",
+    rel: "",
+    children: [],
+  };
+
+  for (const page of mergeWikiPages(pages)) {
+    const file = toWikiTreeFile(page);
+    const parts = file.rel.split("/").filter(Boolean);
+    if (parts.length === 0) continue;
+
+    let cursor = root;
+    for (let index = 0; index < parts.length - 1; index += 1) {
+      const name = parts[index]!;
+      const rel = parts.slice(0, index + 1).join("/");
+      let directory = cursor.children.find(
+        (node): node is WikiTreeDir =>
+          node.type === "dir" && node.name === name,
+      );
+      if (!directory) {
+        directory = { type: "dir", name, rel, children: [] };
+        cursor.children.push(directory);
+      }
+      cursor = directory;
+    }
+
+    const name = parts.at(-1)!;
+    if (
+      !cursor.children.some(
+        (node) => node.type === "file" && node.name === name,
+      )
+    ) {
+      cursor.children.push({ type: "file", name, ...file });
+    }
+  }
+
+  sortChildren(root.children);
+  return root;
+}
+
+export function flattenWikiPageTree(
+  root: WikiTreeDir,
+  collapsed: ReadonlySet<string>,
+): VisibleWikiTreeRow[] {
+  const rows: VisibleWikiTreeRow[] = [];
+  const visit = (nodes: readonly WikiTreeNode[], depth: number) => {
+    for (const node of nodes) {
+      rows.push({ node, depth });
+      if (node.type === "dir" && !collapsed.has(node.rel)) {
+        visit(node.children, depth + 1);
+      }
+    }
+  };
+  visit(root.children, 0);
+  return rows;
+}
+
+export function ancestorDirectories(path: string): string[] {
+  const parts = wikiDisplayPath(path).split("/").filter(Boolean).slice(0, -1);
+  return parts.map((_, index) => parts.slice(0, index + 1).join("/"));
+}
+
+export function toggleWikiDirectory(
+  collapsed: ReadonlySet<string>,
+  directory: string,
+): ReadonlySet<string> {
+  const next = new Set(collapsed);
+  if (next.has(directory)) next.delete(directory);
+  else next.add(directory);
+  return next;
+}
+
+export function expandWikiPageAncestors(
+  collapsed: ReadonlySet<string>,
+  pagePath: string,
+): ReadonlySet<string> {
+  const next = new Set(collapsed);
+  let changed = false;
+  for (const directory of ancestorDirectories(pagePath)) {
+    changed = next.delete(directory) || changed;
+  }
+  return changed ? next : collapsed;
+}

package/dist/dashboard-runtime/dashboard/src/schemas/llm-chat.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 
+import { normalizeFileMemoryStoreName } from "@/lib/file-memory-core";
 import { FILEMEM_DEFAULT_RUN_ID } from "@/lib/memory-storage-mode";
 
 export const chatRoleSchema = z.enum(["user", "assistant", "system"]);
@@ -25,6 +26,7 @@ export const chatRagSchema = z.object({
 // 客户端不允许显式发 `*`——通配符仅由服务端在 SearchMemories 调用前注入。
 const nonWildcardId = z
   .string()
+  .trim()
   .min(1)
   .refine((v) => v !== "*", {
     message: "wildcard '*' is not allowed on the wire; the server applies it",
@@ -46,6 +48,7 @@ const browserFileContextSchema = z.object({
       z.object({
         rel: z.string().min(1).max(512),
         size: z.number().int().nonnegative(),
+        sha256: z.string().min(1).max(256).optional(),
       }),
     )
     .max(300),
@@ -61,7 +64,7 @@ const browserFileContextSchema = z.object({
   cache: memoryFilesCacheSchema,
 });
 
-export const chatMemorySchema = z
+const chatMemoryWireSchema = z
   .object({
     memoryStoreName: z.string().min(1),
     storageMode: z.enum(["ots", "file+ots", "filemem"]).optional(),
@@ -74,34 +77,131 @@ export const chatMemorySchema = z
     topK: z.number().int().min(1).max(50).optional(),
     autoSave: z.boolean().optional(),
     turnId: z.string().min(1).optional(),
-    // 缺省 "search"（语义检索）；"local" 走浏览器文件 API 缓存与词法检索。
+    // 缺省 "search"（语义检索）；"local" 由 Chat BFF 走 Item API + 有界 SHA cache。
     retrievalMode: z.enum(["search", "local"]).optional(),
     fileContext: browserFileContextSchema.optional(),
   })
-  .transform((memory) =>
-    memory.storageMode === "filemem"
-      ? {
-          ...memory,
-          scope: { ...memory.scope, runId: FILEMEM_DEFAULT_RUN_ID },
-          retrievalMode: "local" as const,
-        }
-      : memory,
-  );
+  .superRefine((memory, ctx) => {
+    if (memory.storageMode === "filemem" && !memory.memoryStoreName.trim()) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["memoryStoreName"],
+        message: "File Memory store name cannot be blank",
+      });
+    }
+  });
+
+type ChatMemoryWire = z.infer<typeof chatMemoryWireSchema>;
+
+function normalizeChatMemory(memory: ChatMemoryWire) {
+  return memory.storageMode === "filemem"
+    ? {
+        ...memory,
+        memoryStoreName: normalizeFileMemoryStoreName(memory.memoryStoreName),
+        scope: { ...memory.scope, runId: FILEMEM_DEFAULT_RUN_ID },
+        retrievalMode: "local" as const,
+      }
+    : memory;
+}
+
+export const chatMemorySchema =
+  chatMemoryWireSchema.transform(normalizeChatMemory);
+
+const chatWikiSchema = z
+  .object({
+    memoryStoreName: z.string().trim().min(1),
+    scope: z
+      .object({
+        appId: nonWildcardId,
+        tenantId: nonWildcardId,
+        agentId: nonWildcardId,
+        runId: nonWildcardId,
+      })
+      .strict(),
+    topK: z.number().int().min(1).max(10),
+  })
+  .strict();
 
 /**
  * Server-side validation for the chat endpoint payload. The last message must
  * be from the user; this rule is enforced in the route handler rather than
  * the schema so we can emit a friendlier SSE error frame.
  */
-export const chatRequestSchema = z.object({
-  activeInstance: z.string().min(1).nullable().optional(),
-  providerId: z.string().min(1),
-  model: z.string().min(1),
-  messages: z.array(chatMessageWireSchema).min(1),
-  systemPrompt: z.string().max(8_000).optional(),
-  temperature: z.number().min(0).max(2).optional(),
-  rag: chatRagSchema.optional(),
-  memory: chatMemorySchema.optional(),
-});
+export const chatRequestSchema = z
+  .object({
+    activeInstance: z.string().min(1).nullable().optional(),
+    providerId: z.string().min(1),
+    model: z.string().min(1),
+    messages: z.array(chatMessageWireSchema).min(1),
+    systemPrompt: z.string().max(8_000).optional(),
+    temperature: z.number().min(0).max(2).optional(),
+    rag: chatRagSchema.optional(),
+    memory: chatMemoryWireSchema.optional(),
+    wiki: chatWikiSchema.optional(),
+  })
+  .strict()
+  .superRefine((request, ctx) => {
+    if (!request.wiki) return;
+    if (!request.memory) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["wiki"],
+        message: "Wiki binding requires a Memory binding",
+      });
+      return;
+    }
+    if (!request.memory.storageMode) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["memory", "storageMode"],
+        message: "Wiki binding requires an explicit Memory storage mode",
+      });
+      return;
+    }
+
+    const isFileMemory = request.memory.storageMode === "filemem";
+    const memoryStoreName = isFileMemory
+      ? request.memory.memoryStoreName.trim()
+      : request.memory.memoryStoreName;
+    const wikiStoreName = isFileMemory
+      ? request.wiki.memoryStoreName.trim()
+      : request.wiki.memoryStoreName;
+    if (wikiStoreName !== memoryStoreName) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["wiki", "memoryStoreName"],
+        message: "Wiki and Memory stores must match",
+      });
+    }
+
+    const scopeFields = ["appId", "tenantId", "agentId"] as const;
+    scopeFields.forEach((field) => {
+      if (request.wiki?.scope[field] !== request.memory?.scope[field]) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ["wiki", "scope", field],
+          message: `Wiki and Memory scope.${field} must match`,
+        });
+      }
+    });
+  })
+  .transform((request) => {
+    if (request.memory?.storageMode !== "filemem") return request;
+
+    const memory = normalizeChatMemory(request.memory);
+    return {
+      ...request,
+      memory,
+      ...(request.wiki
+        ? {
+            wiki: {
+              ...request.wiki,
+              memoryStoreName: memory.memoryStoreName,
+              scope: memory.scope,
+            },
+          }
+        : {}),
+    };
+  });
 
 export type ChatRequestInput = z.infer<typeof chatRequestSchema>;

package/dist/dashboard-runtime/dashboard/src/services/file-memory.ts

@@ -1,31 +1,30 @@
 import type {
-  CreateFileMemoryRequest,
-  DeleteFileMemoryRequest,
-  FileMemory,
-  FileMemoryVersion,
-  GetFileMemoryVersionRequest,
-  ListFileMemoriesRequest,
-  ListFileMemoriesResponse,
-  ListFileMemoryVersionsRequest,
-  ListFileMemoryVersionsResponse,
-  ReadFileMemoryRequest,
-  RenameFileMemoryRequest,
-  StatFileMemoryRequest,
-  UpdateFileMemoryRequest,
+  AddItemRequest,
+  DeleteItemRequest,
+  DeleteItemResponse,
+  FileMemoryItem,
+  FileMemoryItemVersion,
+  GetItemRequest,
+  GetItemVersionRequest,
+  ListItemsRequest,
+  ListItemsResponse,
+  ListItemVersionsRequest,
+  ListItemVersionsResponse,
+  RedactItemVersionRequest,
+  UpdateItemRequest,
 } from "@/types/file-memory";
 
 import { apiPost } from "./api-client";
 
 type FileMemoryAction =
+  | "add"
   | "list"
-  | "stat"
-  | "read"
-  | "create"
+  | "get"
   | "update"
-  | "rename"
   | "delete"
   | "versions-list"
-  | "versions-get";
+  | "version-get"
+  | "version-redact";
 
 function route(memoryStoreName: string, action: FileMemoryAction): string {
   return `/api/v1/memory/stores/${encodeURIComponent(
@@ -41,65 +40,58 @@ function post<TResult, TRequest>(
   return apiPost<TResult>(route(memoryStoreName, action), request);
 }
 
-export function listFileMemories(
+export function addItem(
   memoryStoreName: string,
-  request: ListFileMemoriesRequest,
-): Promise<ListFileMemoriesResponse> {
-  return post(memoryStoreName, "list", request);
+  request: AddItemRequest,
+): Promise<FileMemoryItem> {
+  return post(memoryStoreName, "add", request);
 }
 
-export function statFileMemory(
+export function listItems(
   memoryStoreName: string,
-  request: StatFileMemoryRequest,
-): Promise<FileMemory> {
-  return post(memoryStoreName, "stat", request);
-}
-
-export function readFileMemory(
-  memoryStoreName: string,
-  request: ReadFileMemoryRequest,
-): Promise<FileMemory> {
-  return post(memoryStoreName, "read", request);
+  request: ListItemsRequest,
+): Promise<ListItemsResponse> {
+  return post(memoryStoreName, "list", request);
 }
 
-export function createFileMemory(
+export function getItem(
   memoryStoreName: string,
-  request: CreateFileMemoryRequest,
-): Promise<FileMemory> {
-  return post(memoryStoreName, "create", request);
+  request: GetItemRequest,
+): Promise<FileMemoryItem> {
+  return post(memoryStoreName, "get", request);
 }
 
-export function updateFileMemory(
+export function updateItem(
   memoryStoreName: string,
-  request: UpdateFileMemoryRequest,
-): Promise<FileMemory> {
+  request: UpdateItemRequest,
+): Promise<FileMemoryItem> {
   return post(memoryStoreName, "update", request);
 }
 
-export function renameFileMemory(
+export function deleteItem(
   memoryStoreName: string,
-  request: RenameFileMemoryRequest,
-): Promise<FileMemory> {
-  return post(memoryStoreName, "rename", request);
+  request: DeleteItemRequest,
+): Promise<DeleteItemResponse> {
+  return post(memoryStoreName, "delete", request);
 }
 
-export function deleteFileMemory(
+export function listItemVersions(
   memoryStoreName: string,
-  request: DeleteFileMemoryRequest,
-): Promise<Record<string, never>> {
-  return post(memoryStoreName, "delete", request);
+  request: ListItemVersionsRequest,
+): Promise<ListItemVersionsResponse> {
+  return post(memoryStoreName, "versions-list", request);
 }
 
-export function listFileMemoryVersions(
+export function getItemVersion(
   memoryStoreName: string,
-  request: ListFileMemoryVersionsRequest,
-): Promise<ListFileMemoryVersionsResponse> {
-  return post(memoryStoreName, "versions-list", request);
+  request: GetItemVersionRequest,
+): Promise<FileMemoryItemVersion> {
+  return post(memoryStoreName, "version-get", request);
 }
 
-export function getFileMemoryVersion(
+export function redactItemVersion(
   memoryStoreName: string,
-  request: GetFileMemoryVersionRequest,
-): Promise<FileMemoryVersion> {
-  return post(memoryStoreName, "versions-get", request);
+  request: RedactItemVersionRequest,
+): Promise<FileMemoryItemVersion> {
+  return post(memoryStoreName, "version-redact", request);
 }

package/dist/dashboard-runtime/dashboard/src/services/instances.ts

@@ -2,6 +2,7 @@ import type {
   ConnectInstancePayload,
   ImportInstancePayload,
   InstanceActionResult,
+  InstanceConnectivityOverview,
   InstanceDetail,
   InstanceSummary,
   UpdateInstancePayload,
@@ -18,6 +19,10 @@ export async function listInstances(): Promise<InstancesOverview> {
   return apiGet<InstancesOverview>("/api/v1/instances");
 }
 
+export async function getInstanceConnectivity(): Promise<InstanceConnectivityOverview> {
+  return apiGet<InstanceConnectivityOverview>("/api/v1/instances/connectivity");
+}
+
 export async function getInstance(name: string): Promise<InstanceDetail> {
   return apiGet<InstanceDetail>(
     `/api/v1/instances/${encodeURIComponent(name)}`,