@tablestore/tablestore-agent-cli 0.2.11 → 0.3.1

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)}`,

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

@@ -5,93 +5,146 @@ export interface FileMemoryScope {
   runId: string;
 }
 
-export type FileMemoryOperation = "created" | "modified" | "deleted";
+export type ItemView = "basic" | "full";
+export type ItemOperation = "created" | "modified" | "deleted";
 
-export interface FileMemory {
-  memoryId: string;
+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 FileMemoryVersion {
-  memoryVersionId: string;
-  memoryId: string;
-  versionSeq: number;
-  operation: FileMemoryOperation;
+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;
-  sessionId?: string;
+  createdBy?: ItemActor;
   createdAt: string;
+  redacted?: boolean;
+  redactedAt?: string;
+  redactedBy?: ItemActor;
 }
 
-export interface FileMemoryScopedRequest {
+export interface ItemScopedRequest {
   scope: FileMemoryScope;
 }
 
-export interface ListFileMemoriesRequest extends FileMemoryScopedRequest {
+export interface AddItemRequest extends ItemScopedRequest {
+  path: string;
+  content: string;
+  sessionId?: string;
+  view?: ItemView;
+}
+
+export interface ListItemsRequest extends ItemScopedRequest {
   pathPrefix?: string;
-  nextToken?: string;
+  depth?: 0 | 1;
+  view?: ItemView;
   limit?: number;
+  nextToken?: string;
 }
 
-export interface ListFileMemoriesResponse {
-  memories: FileMemory[];
+export interface ListItemsResponse {
+  type: "memoryfile";
+  items: FileMemoryListEntry[];
   nextToken?: string;
   readOnly?: boolean;
 }
 
-export interface ReadFileMemoryRequest extends FileMemoryScopedRequest {
-  path: string;
+export interface GetItemRequest extends ItemScopedRequest {
+  itemId?: string;
+  path?: string;
+  view?: ItemView;
 }
 
-export type StatFileMemoryRequest = ReadFileMemoryRequest;
+export interface UpdateItemRequest extends ItemScopedRequest {
+  itemId: string;
+  content?: string;
+  path?: string;
+  overwrite?: boolean;
+  precondition?: ItemPrecondition;
+  sessionId?: string;
+  view?: ItemView;
+}
 
-export interface CreateFileMemoryRequest extends FileMemoryScopedRequest {
-  path: string;
-  content: string;
+export interface DeleteItemRequest extends ItemScopedRequest {
+  itemId?: string;
+  path?: string;
+  pathPrefix?: string;
+  precondition?: ItemPrecondition;
   sessionId?: string;
 }
 
-export interface UpdateFileMemoryRequest extends CreateFileMemoryRequest {
-  expectedSha256?: string;
+export interface DeleteItemSingleResponse {
+  type: "memoryfile";
+  itemId: string;
+  deleted: true;
 }
 
-export interface RenameFileMemoryRequest extends FileMemoryScopedRequest {
-  fromPath: string;
-  toPath: string;
-  overwrite?: boolean;
-  expectedSha256?: string;
-  sessionId?: string;
+export interface DeleteItemRangedResponse {
+  type: "memoryfile";
+  taskId: string;
+  status: "pending";
 }
 
-export interface DeleteFileMemoryRequest extends FileMemoryScopedRequest {
-  path: string;
-  expectedSha256?: string;
+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 ListFileMemoryVersionsRequest extends FileMemoryScopedRequest {
-  memoryId: string;
-  path?: string;
+export interface ListItemVersionsResponse {
+  type: "memoryfile";
+  versions: FileMemoryItemVersion[];
   nextToken?: string;
-  limit?: number;
-  operation?: FileMemoryOperation;
 }
 
-export interface ListFileMemoryVersionsResponse {
-  versions: FileMemoryVersion[];
-  nextToken?: string;
+export interface GetItemVersionRequest extends ItemScopedRequest {
+  versionId: string;
+  view?: ItemView;
 }
 
-export interface GetFileMemoryVersionRequest extends FileMemoryScopedRequest {
-  memoryId: string;
-  memoryVersionId: string;
-  versionSeq: number;
+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>;
+}

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

@@ -165,15 +165,41 @@ export type DreamTaskStatus =
   | "queued"
   | "running"
   | "planning"
+  | "awaiting_plan_approval"
   | "applying"
   | "completed"
   | "completed_with_failures"
   | "failed"
   | "cancelled";
 
-export type DreamApplyMode = "proposal" | "safe_auto";
+export type DreamApplyMode = "proposal" | "safe_auto" | "plan";
+export type DreamExecutionMode = "single_loop" | "multi_loop";
 export type DreamScopeOutputMode = "preserve_scope" | "promote_scope";
 
+export interface DreamPlan {
+  summary: string;
+  deleteMemoryIds: string[];
+  approvalExpiresAt?: string;
+  approvedAt?: string;
+  approver?: string;
+  executionExpiresAt?: string;
+}
+
+export interface DreamSandboxState {
+  sandboxId?: string;
+  phase?: string;
+  status?: string;
+  startedAt?: string;
+  statusUpdatedAt?: string;
+}
+
+export interface DreamBatchState {
+  batchId?: string;
+  sequence?: number;
+  expectedActionCount?: number;
+  settled?: boolean;
+}
+
 export type DreamActionStatus = "proposed" | "applied" | "skipped" | "failed";
 export type DreamActionType =
   | "ADD"
@@ -216,6 +242,7 @@ export interface DreamTaskInputSummary {
   scopes: MemoryScope[];
   minTimestamp: number;
   maxTimestamp: number;
+  incremental?: boolean;
   sessionCount: number;
   messageCount: number;
   memoryCount: number;
@@ -235,7 +262,16 @@ export interface DreamTaskSummary {
   status: DreamTaskStatus;
   taskType: DreamTaskType;
   applyMode: DreamApplyMode;
+  executionMode: DreamExecutionMode;
   scopeOutputMode: DreamScopeOutputMode;
+  stage?: string;
+  plan?: DreamPlan;
+  sandbox?: DreamSandboxState;
+  submittedBatchCount?: number;
+  lastBatch?: DreamBatchState;
+  agentFinishedAt?: string;
+  failureCode?: string;
+  processedThroughMs?: number;
   instructions?: string;
   input: DreamTaskInputSummary;
   actions: DreamTaskActionStats;
@@ -251,7 +287,15 @@ export interface DreamTask {
   status: DreamTaskStatus;
   taskType?: DreamTaskType;
   applyMode: DreamApplyMode;
+  executionMode?: DreamExecutionMode;
   scopeOutputMode: DreamScopeOutputMode;
+  stage?: string;
+  plan?: DreamPlan;
+  sandbox?: DreamSandboxState;
+  submittedBatchCount?: number;
+  lastBatch?: DreamBatchState;
+  agentFinishedAt?: string;
+  failureCode?: string;
   clientToken?: string;
   triggerType?: string;
   expandedScopeLimit?: number;
@@ -263,6 +307,7 @@ export interface DreamTask {
   maxSessions?: number;
   maxMessages?: number;
   maxMemories?: number;
+  incremental?: boolean;
   confidenceThresholds?: Record<string, number>;
   instructions?: string;
   sessionCount?: number;
@@ -320,14 +365,16 @@ export interface DreamApplyActionResult {
 export interface CreateDreamTaskRequest {
   scopes: MemoryScope[];
   taskType?: DreamTaskType;
-  minTimestamp?: number | string;
-  maxTimestamp?: number | string;
+  executionMode?: DreamExecutionMode;
+  minTimestamp?: number;
+  maxTimestamp?: number;
   maxSessions?: number;
   maxMessages?: number;
   maxMemories?: number;
   expandedScopeLimit?: number;
   scopeOutputMode?: DreamScopeOutputMode;
   applyMode?: DreamApplyMode;
+  incremental?: boolean;
   confidenceThresholds?: Record<string, number>;
   instructions?: string;
   clientToken?: string;