@tablestore/tablestore-agent-cli 0.2.10 → 0.3.1

package/dist/dashboard-runtime/dashboard/src/lib/subspace-history.ts

@@ -0,0 +1,151 @@
+export const MAX_RECENT_SUBSPACES = 10;
+
+const RECENT_STORAGE_KEY_PREFIX = "tsagent.kbSubspaces.v2";
+const ACTIVE_STORAGE_KEY_PREFIX = "tsagent.kbActiveSubspace.v2";
+
+type SubspaceStorage = Pick<Storage, "getItem" | "setItem" | "removeItem">;
+
+function normalizeSubspace(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim();
+  return normalized || null;
+}
+
+export function getRecentSubspaceStorageKey(
+  dataScopeKey: string,
+  knowledgeBaseName: string,
+): string {
+  return `${RECENT_STORAGE_KEY_PREFIX}:${JSON.stringify([
+    dataScopeKey,
+    knowledgeBaseName,
+  ])}`;
+}
+
+export function getActiveSubspaceStorageKey(
+  dataScopeKey: string,
+  knowledgeBaseName: string,
+): string {
+  return `${ACTIVE_STORAGE_KEY_PREFIX}:${JSON.stringify([
+    dataScopeKey,
+    knowledgeBaseName,
+  ])}`;
+}
+
+export function readRecentSubspaces(
+  storage: Pick<SubspaceStorage, "getItem">,
+  dataScopeKey: string,
+  knowledgeBaseName: string,
+): string[] {
+  try {
+    const raw = storage.getItem(
+      getRecentSubspaceStorageKey(dataScopeKey, knowledgeBaseName),
+    );
+    if (!raw) return [];
+    const parsed = JSON.parse(raw) as unknown;
+    if (!Array.isArray(parsed)) return [];
+
+    const seen = new Set<string>();
+    return parsed.reduce<string[]>((recent, item) => {
+      const subspace = normalizeSubspace(item);
+      if (
+        !subspace ||
+        seen.has(subspace) ||
+        recent.length >= MAX_RECENT_SUBSPACES
+      ) {
+        return recent;
+      }
+      seen.add(subspace);
+      recent.push(subspace);
+      return recent;
+    }, []);
+  } catch {
+    return [];
+  }
+}
+
+export function rememberRecentSubspace(
+  storage: Pick<SubspaceStorage, "getItem" | "setItem">,
+  dataScopeKey: string,
+  knowledgeBaseName: string,
+  value: unknown,
+): string[] {
+  const subspace = normalizeSubspace(value);
+  const recent = readRecentSubspaces(storage, dataScopeKey, knowledgeBaseName);
+  if (!subspace) return recent;
+
+  const next = [subspace, ...recent.filter((item) => item !== subspace)].slice(
+    0,
+    MAX_RECENT_SUBSPACES,
+  );
+  try {
+    storage.setItem(
+      getRecentSubspaceStorageKey(dataScopeKey, knowledgeBaseName),
+      JSON.stringify(next),
+    );
+  } catch {
+    // Browser storage availability must not block navigation.
+  }
+  return next;
+}
+
+export function clearRecentSubspaces(
+  storage: Pick<SubspaceStorage, "removeItem">,
+  dataScopeKey: string,
+  knowledgeBaseName: string,
+): void {
+  try {
+    storage.removeItem(
+      getRecentSubspaceStorageKey(dataScopeKey, knowledgeBaseName),
+    );
+  } catch {
+    // Browser storage availability must not block navigation.
+  }
+}
+
+export function readActiveSubspace(
+  storage: Pick<SubspaceStorage, "getItem">,
+  dataScopeKey: string,
+  knowledgeBaseName: string,
+): string | null {
+  try {
+    return normalizeSubspace(
+      storage.getItem(
+        getActiveSubspaceStorageKey(dataScopeKey, knowledgeBaseName),
+      ),
+    );
+  } catch {
+    return null;
+  }
+}
+
+export function writeActiveSubspace(
+  storage: Pick<SubspaceStorage, "setItem">,
+  dataScopeKey: string,
+  knowledgeBaseName: string,
+  value: unknown,
+): void {
+  const subspace = normalizeSubspace(value);
+  if (!subspace) return;
+  try {
+    storage.setItem(
+      getActiveSubspaceStorageKey(dataScopeKey, knowledgeBaseName),
+      subspace,
+    );
+  } catch {
+    // Browser storage availability must not block navigation.
+  }
+}
+
+export function clearActiveSubspace(
+  storage: Pick<SubspaceStorage, "removeItem">,
+  dataScopeKey: string,
+  knowledgeBaseName: string,
+): void {
+  try {
+    storage.removeItem(
+      getActiveSubspaceStorageKey(dataScopeKey, knowledgeBaseName),
+    );
+  } catch {
+    // Browser storage availability must not block navigation.
+  }
+}

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

@@ -1,5 +1,7 @@
 import { z } from "zod";
 
+import { FILEMEM_DEFAULT_RUN_ID } from "@/lib/memory-storage-mode";
+
 export const chatRoleSchema = z.enum(["user", "assistant", "system"]);
 
 export const chatMessageWireSchema = z.object({
@@ -28,21 +30,64 @@ const nonWildcardId = z
     message: "wildcard '*' is not allowed on the wire; the server applies it",
   });
 
-export const chatMemorySchema = z.object({
-  memoryStoreName: z.string().min(1),
-  scope: z.object({
-    appId: nonWildcardId,
-    tenantId: nonWildcardId,
-    agentId: nonWildcardId,
-    runId: nonWildcardId,
-  }),
-  topK: z.number().int().min(1).max(50).optional(),
-  autoSave: z.boolean().optional(),
-  turnId: z.string().min(1).optional(),
-  // 缺省 "search"（语义检索）；"local" 走文件记忆（挂载同步 + 本地词法检索）。
-  retrievalMode: z.enum(["search", "local"]).optional(),
+const memoryFilesCacheSchema = z.object({
+  ok: z.boolean(),
+  listed: z.number().int().nonnegative(),
+  loaded: z.number().int().nonnegative(),
+  reused: z.number().int().nonnegative(),
+  totalBytes: z.number().int().nonnegative(),
+  truncated: z.boolean(),
+  error: z.string().max(4_000).optional(),
+});
+
+const browserFileContextSchema = z.object({
+  files: z
+    .array(
+      z.object({
+        rel: z.string().min(1).max(512),
+        size: z.number().int().nonnegative(),
+      }),
+    )
+    .max(300),
+  hits: z
+    .array(
+      z.object({
+        text: z.string().min(1).max(4_000),
+        source: z.string().min(1).max(512),
+        score: z.number().min(0).max(1),
+      }),
+    )
+    .max(50),
+  cache: memoryFilesCacheSchema,
 });
 
+export const chatMemorySchema = z
+  .object({
+    memoryStoreName: z.string().min(1),
+    storageMode: z.enum(["ots", "file+ots", "filemem"]).optional(),
+    scope: z.object({
+      appId: nonWildcardId,
+      tenantId: nonWildcardId,
+      agentId: nonWildcardId,
+      runId: nonWildcardId,
+    }),
+    topK: z.number().int().min(1).max(50).optional(),
+    autoSave: z.boolean().optional(),
+    turnId: z.string().min(1).optional(),
+    // 缺省 "search"（语义检索）；"local" 走浏览器文件 API 缓存与词法检索。
+    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,
+  );
+
 /**
  * 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

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

@@ -1,63 +1,97 @@
-import type { ChatMemoryWriteScope } from "@/components/chat/chat-config-context";
-import type { MemoryFilesSyncSummary } from "@/types/llm-chat";
-import { apiGet, apiPost } from "./api-client";
+import type {
+  AddItemRequest,
+  DeleteItemRequest,
+  DeleteItemResponse,
+  FileMemoryItem,
+  FileMemoryItemVersion,
+  GetItemRequest,
+  GetItemVersionRequest,
+  ListItemsRequest,
+  ListItemsResponse,
+  ListItemVersionsRequest,
+  ListItemVersionsResponse,
+  RedactItemVersionRequest,
+  UpdateItemRequest,
+} from "@/types/file-memory";
 
-export interface FileMemoryEntry {
-  rel: string;
-  size: number;
-  mtimeMs?: number;
+import { apiPost } from "./api-client";
+
+type FileMemoryAction =
+  | "add"
+  | "list"
+  | "get"
+  | "update"
+  | "delete"
+  | "versions-list"
+  | "version-get"
+  | "version-redact";
+
+function route(memoryStoreName: string, action: FileMemoryAction): string {
+  return `/api/v1/memory/stores/${encodeURIComponent(
+    memoryStoreName,
+  )}/file-memory/${action}`;
+}
+
+function post<TResult, TRequest>(
+  memoryStoreName: string,
+  action: FileMemoryAction,
+  request: TRequest,
+): Promise<TResult> {
+  return apiPost<TResult>(route(memoryStoreName, action), request);
+}
+
+export function addItem(
+  memoryStoreName: string,
+  request: AddItemRequest,
+): Promise<FileMemoryItem> {
+  return post(memoryStoreName, "add", request);
 }
 
-export interface FileMemoryTree {
-  scopeDir: string;
-  files: FileMemoryEntry[];
+export function listItems(
+  memoryStoreName: string,
+  request: ListItemsRequest,
+): Promise<ListItemsResponse> {
+  return post(memoryStoreName, "list", request);
 }
 
-export interface FileMemorySyncResult extends FileMemoryTree {
-  sync: MemoryFilesSyncSummary;
+export function getItem(
+  memoryStoreName: string,
+  request: GetItemRequest,
+): Promise<FileMemoryItem> {
+  return post(memoryStoreName, "get", request);
 }
 
-function scopeQuery(scope: ChatMemoryWriteScope): string {
-  const params = new URLSearchParams();
-  params.set("appId", scope.appId);
-  params.set("tenantId", scope.tenantId);
-  params.set("agentId", scope.agentId);
-  params.set("runId", scope.runId);
-  return params.toString();
+export function updateItem(
+  memoryStoreName: string,
+  request: UpdateItemRequest,
+): Promise<FileMemoryItem> {
+  return post(memoryStoreName, "update", request);
+}
+
+export function deleteItem(
+  memoryStoreName: string,
+  request: DeleteItemRequest,
+): Promise<DeleteItemResponse> {
+  return post(memoryStoreName, "delete", request);
 }
 
-/** 触发一次远端→本地增量同步（AuthorizeMemoryMount + STS），返回文件树与统计。 */
-export async function syncFileMemory(
+export function listItemVersions(
   memoryStoreName: string,
-  scope: ChatMemoryWriteScope,
-): Promise<FileMemorySyncResult> {
-  return apiPost<FileMemorySyncResult>(
-    `/api/v1/memory/stores/${encodeURIComponent(memoryStoreName)}/file-memory/sync`,
-    { scope },
-  );
+  request: ListItemVersionsRequest,
+): Promise<ListItemVersionsResponse> {
+  return post(memoryStoreName, "versions-list", request);
 }
 
-/** 只读本地镜像目录的文件树（不联网）。 */
-export async function getFileMemoryTree(
+export function getItemVersion(
   memoryStoreName: string,
-  scope: ChatMemoryWriteScope,
-): Promise<FileMemoryTree> {
-  return apiGet<FileMemoryTree>(
-    `/api/v1/memory/stores/${encodeURIComponent(
-      memoryStoreName,
-    )}/file-memory/tree?${scopeQuery(scope)}`,
-  );
+  request: GetItemVersionRequest,
+): Promise<FileMemoryItemVersion> {
+  return post(memoryStoreName, "version-get", request);
 }
 
-/** 读取镜像目录内单个文件内容。 */
-export async function getFileMemoryFile(
+export function redactItemVersion(
   memoryStoreName: string,
-  scope: ChatMemoryWriteScope,
-  rel: string,
-): Promise<{ rel: string; content: string }> {
-  return apiGet<{ rel: string; content: string }>(
-    `/api/v1/memory/stores/${encodeURIComponent(
-      memoryStoreName,
-    )}/file-memory/file?${scopeQuery(scope)}&path=${encodeURIComponent(rel)}`,
-  );
+  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)}`,

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

@@ -216,6 +216,19 @@ export async function listMemoryStoreScopes(
  *
  * Capped at MAX_PAGES to bound worst-case fetch budget on stores with very
  * fragmented data — far past that, the suggestion list stops being useful UX.
+ *
+ * `pageSize` is 100 because that is the engine's own ceiling: asking for 200,
+ * 500 or 1000 all come back with exactly 100 items and a byte-identical
+ * nextToken. Raising it buys nothing.
+ *
+ * That matters because nextToken carries the engine's already-seen scope set
+ * (base64 JSON, ~74 bytes per scope) and we hand it back in the query string,
+ * so deep paging eventually blows Node's 16KB `maxHeaderSize` and the request
+ * 431s at somewhere past ~200 scopes. We can't page around it from here — the
+ * real fix is moving the token off the URL — so we degrade instead of
+ * exploding: a page that fails after we already have results returns those
+ * results marked `truncated`, which the UI renders as "first N only" rather
+ * than an error that throws the whole list away.
  */
 export async function listAllMemoryStoreScopes(
   memoryStoreName: string,
@@ -230,10 +243,18 @@ export async function listAllMemoryStoreScopes(
   let truncated = false;
 
   for (let page = 0; page < maxPages; page++) {
-    const data = await listMemoryStoreScopes(memoryStoreName, scope, {
-      limit: pageSize,
-      nextToken,
-    });
+    let data: Awaited<ReturnType<typeof listMemoryStoreScopes>>;
+    try {
+      data = await listMemoryStoreScopes(memoryStoreName, scope, {
+        limit: pageSize,
+        nextToken,
+      });
+    } catch (error) {
+      // Nothing to show yet — let the caller surface a real error state.
+      if (items.length === 0) throw error;
+      truncated = true;
+      break;
+    }
     for (const s of data.items) {
       const key = `${s.appId ?? ""}|${s.tenantId ?? ""}|${s.agentId ?? ""}|${s.runId ?? ""}`;
       if (seen.has(key)) continue;
@@ -402,7 +423,26 @@ export async function applyDreamActions(
 }> {
   return apiPost(
     `/api/v1/memory/stores/${encodeURIComponent(memoryStoreName)}/dream-tasks/${encodeURIComponent(dreamId)}/actions/apply`,
-    applier ? { actionIds, applier } : { actionIds },
+    applier
+      ? { mode: "actions", actionIds, applier }
+      : { mode: "actions", actionIds },
+  );
+}
+
+export async function approveDreamPlan(
+  memoryStoreName: string,
+  dreamId: string,
+  approver: string,
+): Promise<{
+  memoryStoreName: string;
+  dreamId: string;
+  status: string;
+  approvedAt?: string;
+  executionExpiresAt?: string;
+}> {
+  return apiPost(
+    `/api/v1/memory/stores/${encodeURIComponent(memoryStoreName)}/dream-tasks/${encodeURIComponent(dreamId)}/actions/apply`,
+    { mode: "plan", approver },
   );
 }
 

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

@@ -0,0 +1,150 @@
+export interface FileMemoryScope {
+  appId: string;
+  tenantId: string;
+  agentId: string;
+  runId: string;
+}
+
+export type ItemView = "basic" | "full";
+export type ItemOperation = "created" | "modified" | "deleted";
+
+export interface ItemActor {
+  actorType: string;
+  actorId: string;
+}
+
+export interface ItemPrecondition {
+  expectedVersionId: string;
+}
+
+export interface FileMemoryItem {
+  type: "memoryfile";
+  itemId: string;
+  scope: FileMemoryScope;
+  path: string;
+  content?: string;
+  contentSha256: string;
+  contentSizeBytes: number;
+  latestSeq: number;
+  latestVersionId: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface FileMemoryPrefix {
+  type: "memoryfile_prefix";
+  scope: FileMemoryScope;
+  path: string;
+}
+
+export type FileMemoryListEntry = FileMemoryItem | FileMemoryPrefix;
+
+export interface FileMemoryItemVersion {
+  type: "memoryfile";
+  versionId: string;
+  itemId: string;
+  scope: FileMemoryScope;
+  operation: ItemOperation;
+  path: string;
+  content?: string;
+  contentSha256: string;
+  contentSizeBytes: number;
+  createdBy?: ItemActor;
+  createdAt: string;
+  redacted?: boolean;
+  redactedAt?: string;
+  redactedBy?: ItemActor;
+}
+
+export interface ItemScopedRequest {
+  scope: FileMemoryScope;
+}
+
+export interface AddItemRequest extends ItemScopedRequest {
+  path: string;
+  content: string;
+  sessionId?: string;
+  view?: ItemView;
+}
+
+export interface ListItemsRequest extends ItemScopedRequest {
+  pathPrefix?: string;
+  depth?: 0 | 1;
+  view?: ItemView;
+  limit?: number;
+  nextToken?: string;
+}
+
+export interface ListItemsResponse {
+  type: "memoryfile";
+  items: FileMemoryListEntry[];
+  nextToken?: string;
+  readOnly?: boolean;
+}
+
+export interface GetItemRequest extends ItemScopedRequest {
+  itemId?: string;
+  path?: string;
+  view?: ItemView;
+}
+
+export interface UpdateItemRequest extends ItemScopedRequest {
+  itemId: string;
+  content?: string;
+  path?: string;
+  overwrite?: boolean;
+  precondition?: ItemPrecondition;
+  sessionId?: string;
+  view?: ItemView;
+}
+
+export interface DeleteItemRequest extends ItemScopedRequest {
+  itemId?: string;
+  path?: string;
+  pathPrefix?: string;
+  precondition?: ItemPrecondition;
+  sessionId?: string;
+}
+
+export interface DeleteItemSingleResponse {
+  type: "memoryfile";
+  itemId: string;
+  deleted: true;
+}
+
+export interface DeleteItemRangedResponse {
+  type: "memoryfile";
+  taskId: string;
+  status: "pending";
+}
+
+export type DeleteItemResponse =
+  DeleteItemSingleResponse | DeleteItemRangedResponse;
+
+export interface ListItemVersionsRequest extends ItemScopedRequest {
+  itemId?: string;
+  sessionId?: string;
+  apiKeyId?: string;
+  createdAtGte?: string;
+  createdAtLte?: string;
+  operation?: ItemOperation;
+  view?: ItemView;
+  limit?: number;
+  nextToken?: string;
+}
+
+export interface ListItemVersionsResponse {
+  type: "memoryfile";
+  versions: FileMemoryItemVersion[];
+  nextToken?: string;
+}
+
+export interface GetItemVersionRequest extends ItemScopedRequest {
+  versionId: string;
+  view?: ItemView;
+}
+
+export interface RedactItemVersionRequest extends ItemScopedRequest {
+  versionId: string;
+  sessionId?: string;
+}

package/dist/dashboard-runtime/dashboard/src/types/instance.ts

@@ -74,3 +74,20 @@ export interface InstanceActionResult {
   activeInstance: string | null;
   instance: InstanceSummary;
 }
+
+export type InstanceConnectivityReason =
+  "timeout" | "dns" | "connection" | "tls" | "network";
+
+export interface InstanceConnectivity {
+  configured: boolean;
+  reachable: boolean | null;
+  checkedAt: string;
+  latencyMs?: number;
+  httpStatus?: number;
+  reason?: InstanceConnectivityReason;
+  message?: string;
+}
+
+export interface InstanceConnectivityOverview {
+  items: Record<string, InstanceConnectivity>;
+}