@tablestore/tablestore-agent-cli 0.3.1 → 0.4.1

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

@@ -0,0 +1,230 @@
+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,
+  fromWikiRawItemPath,
+  hasCallerWikiId,
+  readExactScopeFromQuery,
+  readWikiJsonBody,
+  sanitizeWikiSourceErrorResponse,
+  toPublicWikiSource,
+  toWikiRawItemPath,
+} from "../_helpers";
+import { toAgentWikiScope } from "../../_scope";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+interface RouteContext {
+  params: Promise<{ store: string }>;
+}
+
+interface SourceAddress {
+  path: string;
+  physicalPath: string;
+}
+
+function invalidRequest(message: string) {
+  return errorResponse("BAD_REQUEST", message, 400);
+}
+
+function readSourceAddress(rawPath: unknown): SourceAddress | null {
+  try {
+    const physicalPath = toWikiRawItemPath(rawPath);
+    return {
+      path: fromWikiRawItemPath(physicalPath),
+      physicalPath,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function readExpectedVersionId(raw: unknown): string | null {
+  if (typeof raw !== "string") return null;
+  const versionId = raw.trim();
+  return versionId || null;
+}
+
+function currentItemId(
+  response: StandardResponse,
+  expectedPhysicalPath: string,
+): string {
+  if (
+    !response.data ||
+    typeof response.data !== "object" ||
+    Array.isArray(response.data)
+  ) {
+    throw new Error("Invalid Memory Item response");
+  }
+  const item = response.data as Record<string, unknown>;
+  if (
+    typeof item.itemId !== "string" ||
+    !item.itemId ||
+    item.path !== expectedPhysicalPath
+  ) {
+    throw new Error("Invalid Memory Item response");
+  }
+  toPublicWikiSource(item);
+  return item.itemId;
+}
+
+function safeUpdatedSource(
+  response: StandardResponse,
+  expectedPhysicalPath: string,
+) {
+  const source = toPublicWikiSource(response.data);
+  if (toWikiRawItemPath(source.path) !== expectedPhysicalPath) {
+    throw new Error("Invalid Memory Item response");
+  }
+  return source;
+}
+
+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);
+    if (!scope || hasCallerWikiId(request)) {
+      return invalidRequest(
+        "An exact scope without legacy Wiki identity is required",
+      );
+    }
+    const source = readSourceAddress(params.get("path"));
+    if (!source) return invalidRequest("A valid source path is required");
+
+    const response = await auth.memory.getItem(
+      {
+        memoryStoreName: store,
+        scope: toAgentWikiScope(scope),
+        path: source.physicalPath,
+        view: "full",
+      },
+      request.signal,
+    );
+    if (response.code !== "SUCCESS") {
+      return forwardResponse(sanitizeWikiSourceErrorResponse(response));
+    }
+    return successResponse(safeUpdatedSource(response, source.physicalPath));
+  } catch (error) {
+    return handleApiError(error);
+  }
+}
+
+export async function PUT(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);
+    const expectedVersionId = readExpectedVersionId(body?.expectedVersionId);
+    let content: string | null = null;
+    try {
+      content = assertWikiSourceContent(body?.content);
+    } catch {
+      content = null;
+    }
+    if (
+      !body ||
+      hasCallerWikiId(request, body) ||
+      !expectedVersionId ||
+      content === null
+    ) {
+      return invalidRequest("Invalid Wiki source update request");
+    }
+    const source = readSourceAddress(body.path);
+    if (!source) return invalidRequest("Invalid Wiki source update request");
+
+    const current = await auth.memory.getItem(
+      {
+        memoryStoreName: store,
+        scope: toAgentWikiScope(body.scope),
+        path: source.physicalPath,
+        view: "full",
+      },
+      request.signal,
+    );
+    if (current.code !== "SUCCESS") {
+      return forwardResponse(sanitizeWikiSourceErrorResponse(current));
+    }
+    const itemId = currentItemId(current, source.physicalPath);
+
+    const response = await auth.memory.updateItem(
+      {
+        memoryStoreName: store,
+        scope: toAgentWikiScope(body.scope),
+        itemId,
+        content,
+        precondition: { expectedVersionId },
+        view: "full",
+      },
+      request.signal,
+    );
+    if (response.code !== "SUCCESS") {
+      return forwardResponse(sanitizeWikiSourceErrorResponse(response));
+    }
+    return successResponse(safeUpdatedSource(response, source.physicalPath));
+  } catch (error) {
+    return handleApiError(error);
+  }
+}
+
+export async function DELETE(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);
+    const expectedVersionId = readExpectedVersionId(body?.expectedVersionId);
+    if (!body || hasCallerWikiId(request, body) || !expectedVersionId) {
+      return invalidRequest("Invalid Wiki source delete request");
+    }
+    const source = readSourceAddress(body.path);
+    if (!source) return invalidRequest("Invalid Wiki source delete request");
+
+    const current = await auth.memory.getItem(
+      {
+        memoryStoreName: store,
+        scope: toAgentWikiScope(body.scope),
+        path: source.physicalPath,
+        view: "full",
+      },
+      request.signal,
+    );
+    if (current.code !== "SUCCESS") {
+      return forwardResponse(sanitizeWikiSourceErrorResponse(current));
+    }
+    const itemId = currentItemId(current, source.physicalPath);
+
+    const response = await auth.memory.deleteItem(
+      {
+        memoryStoreName: store,
+        scope: toAgentWikiScope(body.scope),
+        itemId,
+        precondition: { expectedVersionId },
+      },
+      request.signal,
+    );
+    if (response.code !== "SUCCESS") {
+      return forwardResponse(sanitizeWikiSourceErrorResponse(response));
+    }
+    return successResponse({ path: source.path, deleted: true });
+  } catch (error) {
+    return handleApiError(error);
+  }
+}

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/app/api/v1/memory/stores/route.ts

@@ -10,6 +10,7 @@ import {
   successResponse,
 } from "@/lib/server/api-helpers";
 import { paginateAll } from "@tablestore/tablestore-agent-sdk";
+import { normalizeMemoryStoreContract } from "@/lib/server/memory-store-contract";
 
 /**
  * GET  /api/v1/memory/stores   List all memory stores (auto-paginated).
@@ -36,18 +37,24 @@ export async function GET(request: NextRequest) {
           const resp = await memory.getMemoryStore({
             memoryStoreName: item.memoryStoreName,
           });
-          if (resp.code !== "SUCCESS") return item;
+          if (resp.code !== "SUCCESS") {
+            return normalizeMemoryStoreContract(item);
+          }
           const data = (resp.data ?? {}) as {
             storageMode?: string;
             description?: string;
+            inputType?: string;
+            outputTypes?: string[];
           };
-          return {
+          return normalizeMemoryStoreContract({
             ...item,
             ...(data.storageMode ? { storageMode: data.storageMode } : {}),
             ...(data.description ? { description: data.description } : {}),
-          };
+            ...(data.inputType ? { inputType: data.inputType } : {}),
+            ...(data.outputTypes ? { outputTypes: data.outputTypes } : {}),
+          });
         } catch {
-          return item;
+          return normalizeMemoryStoreContract(item);
         }
       }),
     );

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 ?? ""}