@tablestore/tablestore-agent-cli 0.1.8 → 0.2.0

package/dist/dashboard-runtime/dashboard/src/app/api/v1/logs/client/route.ts

@@ -0,0 +1,70 @@
+import { type NextRequest } from "next/server";
+
+import { createLogger } from "@tablestore/tablestore-agent-shared";
+
+import {
+  ensureApiLogContext,
+  errorResponse,
+  successResponse,
+} from "@/lib/server/api-helpers";
+
+export const runtime = "nodejs";
+
+const MAX_CLIENT_LOG_BYTES = 16 * 1024;
+const browserLogger = createLogger("dashboard.browser");
+
+export async function POST(request: NextRequest) {
+  ensureApiLogContext(request);
+
+  const length = Number(request.headers.get("content-length") ?? "0");
+  if (Number.isFinite(length) && length > MAX_CLIENT_LOG_BYTES) {
+    return errorResponse("BAD_REQUEST", "Client log payload is too large", 400, {
+      errorSource: "browser",
+    });
+  }
+
+  const raw = await request.text();
+  if (Buffer.byteLength(raw, "utf8") > MAX_CLIENT_LOG_BYTES) {
+    return errorResponse("BAD_REQUEST", "Client log payload is too large", 400, {
+      errorSource: "browser",
+    });
+  }
+
+  let body: Record<string, unknown>;
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    body = parsed && typeof parsed === "object" && !Array.isArray(parsed)
+      ? (parsed as Record<string, unknown>)
+      : {};
+  } catch {
+    return errorResponse("BAD_REQUEST", "Client log payload must be JSON", 400, {
+      errorSource: "browser",
+    });
+  }
+
+  const event = typeof body.event === "string" ? body.event : "browser.error";
+  const message =
+    typeof body.message === "string" ? body.message : "Browser error captured";
+  const level = body.level === "warn" || body.level === "info" ? body.level : "error";
+
+  browserLogger.log({
+    level,
+    event,
+    message,
+    traceId: typeof body.traceId === "string" ? body.traceId : undefined,
+    requestId: typeof body.requestId === "string" ? body.requestId : undefined,
+    errorSource: "browser",
+    error: {
+      name: typeof body.name === "string" ? body.name : "BrowserError",
+      message,
+      stack: typeof body.stack === "string" ? body.stack : undefined,
+    },
+    details: {
+      url: typeof body.url === "string" ? body.url : undefined,
+      userAgent: request.headers.get("user-agent") ?? undefined,
+      digest: typeof body.digest === "string" ? body.digest : undefined,
+    },
+  });
+
+  return successResponse({ logged: true });
+}

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

@@ -0,0 +1,84 @@
+import type { MemoryScope } from "@tablestore/tablestore-agent-shared";
+
+/**
+ * Extract a {@link MemoryScope} from URL query parameters.
+ *
+ * Supported parameter names match the Memory API contract in
+ * `ref/mem_api_docs.txt`:
+ *   - appId / app_id           (required for a non-null scope)
+ *   - tenantId / tenant_id     (optional)
+ *   - agentId / agent_id       (optional)
+ *   - runId / run_id           (optional)
+ *
+ * Returns `null` when `appId` is absent, so the caller can omit the whole
+ * `scope` field from the SDK request.
+ */
+export function readScopeFromQuery(
+  params: URLSearchParams,
+): MemoryScope | null {
+  const appId = params.get("appId") ?? params.get("app_id") ?? "";
+  if (!appId) return null;
+
+  const scope: MemoryScope = { appId };
+  const tenantId = params.get("tenantId") ?? params.get("tenant_id");
+  const agentId = params.get("agentId") ?? params.get("agent_id");
+  const runId = params.get("runId") ?? params.get("run_id");
+
+  if (tenantId) scope.tenantId = tenantId;
+  if (agentId) scope.agentId = agentId;
+  if (runId) scope.runId = runId;
+
+  return scope;
+}
+
+/**
+ * Read a {@link MemoryScope} from a JSON body. Unlike the query-string
+ * variant this does NOT fall back to snake_case (bodies are already in
+ * camelCase by convention).
+ */
+export function readScopeFromBody(
+  body: Record<string, unknown> | null | undefined,
+): MemoryScope | null {
+  if (!body) return null;
+  const raw = body.scope;
+  if (raw === null || typeof raw !== "object") return null;
+  const rec = raw as Record<string, unknown>;
+  const appId = typeof rec.appId === "string" ? rec.appId : "";
+  if (!appId) return null;
+
+  const scope: MemoryScope = { appId };
+  if (typeof rec.tenantId === "string") scope.tenantId = rec.tenantId;
+  if (typeof rec.agentId === "string") scope.agentId = rec.agentId;
+  if (typeof rec.runId === "string") scope.runId = rec.runId;
+  return scope;
+}
+
+/**
+ * Parse the standard pagination query shared by all Memory list routes.
+ * Accepts both `maxResults` and `limit` (the Dashboard frontend uses
+ * `limit`).
+ */
+export function readPaginationFromQuery(params: URLSearchParams): {
+  maxResults: number;
+  nextToken?: string;
+} {
+  const raw = params.get("maxResults") ?? params.get("limit") ?? "20";
+  const parsed = Number(raw);
+  const maxResults = Number.isFinite(parsed) && parsed > 0 ? parsed : 20;
+  const nextToken = params.get("nextToken") ?? undefined;
+  return nextToken ? { maxResults, nextToken } : { maxResults };
+}
+
+/**
+ * Optional timestamp range filter used by messages / requests.
+ */
+export function readTimeRangeFromQuery(
+  params: URLSearchParams,
+): Record<string, string> {
+  const out: Record<string, string> = {};
+  const min = params.get("minTimestamp");
+  const max = params.get("maxTimestamp");
+  if (min) out.minTimestamp = min;
+  if (max) out.maxTimestamp = max;
+  return out;
+}

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

@@ -0,0 +1,64 @@
+import { type NextRequest } from "next/server";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+import {
+  forwardResponse,
+  handleApiError,
+  requireClients,
+  successResponse,
+} from "@/lib/server/api-helpers";
+import { normalizeMemoryMessagesPage } from "@tablestore/tablestore-agent-sdk";
+
+import {
+  readPaginationFromQuery,
+  readScopeFromQuery,
+  readTimeRangeFromQuery,
+} from "../_scope";
+
+/**
+ * GET /api/v1/memory/stores/:store/messages   List session messages (paginated).
+ * Optional filters: minTimestamp, maxTimestamp.
+ */
+
+interface RouteContext {
+  params: Promise<{ store: string }>;
+}
+
+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 { memory } = auth;
+
+    const url = new URL(request.url);
+    const { maxResults, nextToken } = readPaginationFromQuery(url.searchParams);
+    const scope = readScopeFromQuery(url.searchParams);
+    const timeRange = readTimeRangeFromQuery(url.searchParams);
+
+    const baseRequest: Record<string, unknown> = {
+      memoryStoreName: store,
+      limit: maxResults,
+      ...timeRange,
+    };
+    if (nextToken) baseRequest.nextToken = nextToken;
+    if (scope) baseRequest.scope = scope;
+
+    const response = await memory.listMemoryStoreMessages(baseRequest);
+    if (response.code !== "SUCCESS") {
+      return forwardResponse(response);
+    }
+    const page = normalizeMemoryMessagesPage(response);
+    return successResponse({
+      items: page.items,
+      totalCount: page.totalCount,
+      nextToken: page.nextToken,
+      scope: page.scope ?? scope,
+      memoryStoreName: store,
+    });
+  } catch (error) {
+    return handleApiError(error);
+  }
+}

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

@@ -0,0 +1,65 @@
+import { type NextRequest } from "next/server";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+import {
+  handleApiError,
+  requireClients,
+  successResponse,
+} from "@/lib/server/api-helpers";
+import { fetchPage } from "@tablestore/tablestore-agent-sdk";
+
+import {
+  readPaginationFromQuery,
+  readScopeFromQuery,
+  readTimeRangeFromQuery,
+} from "../_scope";
+
+/**
+ * GET /api/v1/memory/stores/:store/requests   List ingest request logs (paginated).
+ * Optional filters: operation, minTimestamp, maxTimestamp.
+ */
+
+interface RouteContext {
+  params: Promise<{ store: string }>;
+}
+
+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 { memory } = auth;
+
+    const url = new URL(request.url);
+    const { maxResults, nextToken } = readPaginationFromQuery(url.searchParams);
+    const scope = readScopeFromQuery(url.searchParams);
+    const timeRange = readTimeRangeFromQuery(url.searchParams);
+    const operation = url.searchParams.get("operation") ?? undefined;
+
+    const baseRequest: Record<string, unknown> = {
+      memoryStoreName: store,
+      limit: maxResults,
+      ...timeRange,
+    };
+    if (operation) baseRequest.operation = operation;
+    if (nextToken) baseRequest.nextToken = nextToken;
+    if (scope) baseRequest.scope = scope;
+
+    const page = await fetchPage(
+      (req) => memory.listMemoryStoreRequests(req),
+      baseRequest,
+      "requests",
+    );
+    return successResponse({
+      items: page.items,
+      totalCount: page.totalCount,
+      nextToken: page.nextToken,
+      scope,
+      memoryStoreName: store,
+    });
+  } catch (error) {
+    return handleApiError(error);
+  }
+}

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

@@ -0,0 +1,78 @@
+import { type NextRequest } from "next/server";
+
+import {
+  forwardResponse,
+  handleApiError,
+  requireClients,
+} from "@/lib/server/api-helpers";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+/**
+ * GET    /api/v1/memory/stores/:store   Describe a memory store.
+ * PUT    /api/v1/memory/stores/:store   Update a memory store.
+ * DELETE /api/v1/memory/stores/:store   Delete a memory store.
+ */
+
+interface RouteContext {
+  params: Promise<{ store: string }>;
+}
+
+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 { memory } = auth;
+
+    const resp = await memory.getMemoryStore({ memoryStoreName: store });
+    return forwardResponse(resp);
+  } 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 { memory } = auth;
+
+    let body: Record<string, unknown>;
+    try {
+      body = (await request.json()) as Record<string, unknown>;
+    } catch {
+      return forwardResponse({
+        code: "BAD_REQUEST",
+        data: null,
+        message: "Request body must be JSON",
+      });
+    }
+
+    const { memoryStoreName: _ignored, ...safeBody } = body;
+    void _ignored;
+    const resp = await memory.updateMemoryStore({
+      ...safeBody,
+      memoryStoreName: store,
+    });
+    return forwardResponse(resp);
+  } 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 { memory } = auth;
+
+    const resp = await memory.deleteMemoryStore({ memoryStoreName: store });
+    return forwardResponse(resp);
+  } catch (error) {
+    return handleApiError(error);
+  }
+}

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

@@ -0,0 +1,49 @@
+import { type NextRequest } from "next/server";
+
+import {
+  forwardResponse,
+  handleApiError,
+  requireClients,
+} from "@/lib/server/api-helpers";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+/**
+ * POST /api/v1/memory/stores/:store/search   Semantic search over memory units.
+ */
+
+interface RouteContext {
+  params: Promise<{ store: string }>;
+}
+
+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 { memory } = auth;
+
+    let body: Record<string, unknown>;
+    try {
+      body = (await request.json()) as Record<string, unknown>;
+    } catch {
+      return forwardResponse({
+        code: "BAD_REQUEST",
+        data: null,
+        message: "Request body must be JSON",
+      });
+    }
+
+    // Strip client-supplied memoryStoreName so the URL-derived value wins (D2).
+    const { memoryStoreName: _ignored, ...safeBody } = body;
+    void _ignored;
+    const resp = await memory.searchMemories({
+      ...safeBody,
+      memoryStoreName: store,
+    });
+    return forwardResponse(resp);
+  } catch (error) {
+    return handleApiError(error);
+  }
+}

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

@@ -0,0 +1,126 @@
+import { type NextRequest } from "next/server";
+
+import {
+  forwardResponse,
+  handleApiError,
+  requireClients,
+} from "@/lib/server/api-helpers";
+
+import { readScopeFromBody, readScopeFromQuery } from "../../_scope";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+/**
+ * GET    /api/v1/memory/stores/:store/units/:memoryId   Describe a unit.
+ * PUT    /api/v1/memory/stores/:store/units/:memoryId   Update a unit.
+ * DELETE /api/v1/memory/stores/:store/units/:memoryId   Delete a unit.
+ *
+ * All three verbs require a scope (appId is mandatory). GET reads the scope
+ * from query parameters; PUT/DELETE accept the scope inside the JSON body.
+ */
+
+interface RouteContext {
+  params: Promise<{ store: string; memoryId: string }>;
+}
+
+export async function GET(request: NextRequest, context: RouteContext) {
+  try {
+    const { store, memoryId } = await context.params;
+    const auth = requireClients(request);
+    if (!("memory" in auth)) return auth;
+    const { memory } = auth;
+
+    const url = new URL(request.url);
+    const scope = readScopeFromQuery(url.searchParams);
+
+    const req: Record<string, unknown> = {
+      memoryStoreName: store,
+      memoryId,
+    };
+    if (scope) req.scope = scope;
+
+    const resp = await memory.getMemory(req);
+    return forwardResponse(resp);
+  } catch (error) {
+    return handleApiError(error);
+  }
+}
+
+export async function PUT(request: NextRequest, context: RouteContext) {
+  try {
+    const { store, memoryId } = await context.params;
+    const auth = requireClients(request);
+    if (!("memory" in auth)) return auth;
+    const { memory } = auth;
+
+    let body: Record<string, unknown>;
+    try {
+      body = (await request.json()) as Record<string, unknown>;
+    } catch {
+      return forwardResponse({
+        code: "BAD_REQUEST",
+        data: null,
+        message: "Request body must be JSON",
+      });
+    }
+
+    // If the body carries a scope it wins; otherwise fall back to query.
+    const url = new URL(request.url);
+    const scopeFromBody = readScopeFromBody(body);
+    const scope = scopeFromBody ?? readScopeFromQuery(url.searchParams);
+
+    const {
+      memoryStoreName: _ignoredStore,
+      memoryId: _ignoredId,
+      ...safeBody
+    } = body;
+    void _ignoredStore;
+    void _ignoredId;
+    const payload: Record<string, unknown> = {
+      ...safeBody,
+      memoryStoreName: store,
+      memoryId,
+    };
+    if (scope) payload.scope = scope;
+
+    const resp = await memory.updateMemory(payload);
+    return forwardResponse(resp);
+  } catch (error) {
+    return handleApiError(error);
+  }
+}
+
+export async function DELETE(request: NextRequest, context: RouteContext) {
+  try {
+    const { store, memoryId } = await context.params;
+    const auth = requireClients(request);
+    if (!("memory" in auth)) return auth;
+    const { memory } = auth;
+
+    // DELETE bodies are legal in fetch/HTTP. Try to parse scope from body
+    // but also accept scope via query parameters.
+    let body: Record<string, unknown> | null = null;
+    try {
+      const text = await request.text();
+      if (text) body = JSON.parse(text) as Record<string, unknown>;
+    } catch {
+      body = null;
+    }
+
+    const url = new URL(request.url);
+    const scope =
+      readScopeFromBody(body) ?? readScopeFromQuery(url.searchParams);
+
+    const payload: Record<string, unknown> = {
+      memoryStoreName: store,
+      memoryId,
+    };
+    if (scope) payload.scope = scope;
+
+    const resp = await memory.deleteMemory(payload);
+    return forwardResponse(resp);
+  } catch (error) {
+    return handleApiError(error);
+  }
+}

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

@@ -0,0 +1,85 @@
+import { type NextRequest } from "next/server";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+import {
+  forwardResponse,
+  handleApiError,
+  requireClients,
+  successResponse,
+} from "@/lib/server/api-helpers";
+import { fetchPage } from "@tablestore/tablestore-agent-sdk";
+
+import { readPaginationFromQuery, readScopeFromQuery } from "../_scope";
+
+/**
+ * GET  /api/v1/memory/stores/:store/units   List memory units (paginated).
+ * POST /api/v1/memory/stores/:store/units   Add memory units (batch).
+ */
+
+interface RouteContext {
+  params: Promise<{ store: string }>;
+}
+
+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 { memory } = auth;
+
+    const url = new URL(request.url);
+    const { maxResults, nextToken } = readPaginationFromQuery(url.searchParams);
+    const scope = readScopeFromQuery(url.searchParams);
+
+    const baseRequest: Record<string, unknown> = {
+      memoryStoreName: store,
+      limit: maxResults,
+    };
+    if (nextToken) baseRequest.nextToken = nextToken;
+    if (scope) baseRequest.scope = scope;
+
+    const page = await fetchPage(
+      (req) => memory.listMemories(req),
+      baseRequest,
+      "memories",
+    );
+    return successResponse({
+      items: page.items,
+      totalCount: page.totalCount,
+      nextToken: page.nextToken,
+      scope,
+      memoryStoreName: store,
+    });
+  } 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 { memory } = auth;
+
+    let body: Record<string, unknown>;
+    try {
+      body = (await request.json()) as Record<string, unknown>;
+    } catch {
+      return forwardResponse({
+        code: "BAD_REQUEST",
+        data: null,
+        message: "Request body must be JSON",
+      });
+    }
+
+    const { memoryStoreName: _ignored, ...safeBody } = body;
+    void _ignored;
+    const resp = await memory.addMemories({ ...safeBody, memoryStoreName: store });
+    return forwardResponse(resp);
+  } catch (error) {
+    return handleApiError(error);
+  }
+}

package/dist/dashboard-runtime/dashboard/src/app/api/v1/memory/stores/route.ts

@@ -0,0 +1,60 @@
+import { type NextRequest } from "next/server";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+import {
+  forwardResponse,
+  handleApiError,
+  requireClients,
+  successResponse,
+} from "@/lib/server/api-helpers";
+import { paginateAll } from "@tablestore/tablestore-agent-sdk";
+
+/**
+ * GET  /api/v1/memory/stores   List all memory stores (auto-paginated).
+ * POST /api/v1/memory/stores   Create a new memory store.
+ */
+
+export async function GET(request: NextRequest) {
+  try {
+    const auth = requireClients(request);
+    if (!("memory" in auth)) return auth;
+    const { memory } = auth;
+
+    const { items, totalCount } = await paginateAll(
+      (req) => memory.listMemoryStores(req),
+      {},
+      "stores",
+      100,
+      "limit",
+    );
+    return successResponse({ items, totalCount });
+  } catch (error) {
+    return handleApiError(error);
+  }
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const auth = requireClients(request);
+    if (!("memory" in auth)) return auth;
+    const { memory } = auth;
+
+    let body: Record<string, unknown>;
+    try {
+      body = (await request.json()) as Record<string, unknown>;
+    } catch {
+      return forwardResponse({
+        code: "BAD_REQUEST",
+        data: null,
+        message: "Request body must be JSON",
+      });
+    }
+
+    const resp = await memory.createMemoryStore(body);
+    return forwardResponse(resp);
+  } catch (error) {
+    return handleApiError(error);
+  }
+}