feat: add Memory event TUI (#1906)

Author: notgitika

src/components/MemoryPicker.tsx

@@ -0,0 +1,68 @@
+import type { MemorySummary } from "@aws-sdk/client-bedrock-agentcore-control";
+import { useNavigate } from "react-router";
+import type { ScreenProps } from "../handlers/types";
+import { coreOptsFromCtx } from "../handlers/utils";
+import { formatTimestamp } from "./formatTimestamp";
+import { PaginatedTablePicker } from "./PaginatedTablePicker";
+import type { DataTableColumn } from "./ui/data-table";
+
+interface MemoryRow extends Record<string, unknown> {
+  memoryId: string;
+  status: string;
+  updatedAt: string;
+}
+
+export const memoryColumns = [
+  { key: "memoryId", header: "id", flex: true },
+  { key: "status", header: "status", width: 13 },
+  {
+    key: "updatedAt",
+    header: "updated UTC",
+    width: 16,
+    render: formatTimestamp,
+  },
+] satisfies DataTableColumn<MemoryRow>[];
+
+function toRow(memory: MemorySummary): MemoryRow {
+  return {
+    memoryId: memory.id ?? "",
+    status: memory.status ?? "-",
+    updatedAt: memory.updatedAt?.toISOString() ?? "-",
+  };
+}
+
+export interface MemoryPickerProps extends ScreenProps {
+  breadcrumb: string[];
+  description?: string;
+  onSelect: (memoryId: string) => void;
+}
+
+export function MemoryPicker({ ctx, core, breadcrumb, description, onSelect }: MemoryPickerProps) {
+  const opts = coreOptsFromCtx(ctx);
+  const navigate = useNavigate();
+  const goBack = () => navigate("/" + breadcrumb.slice(0, -1).join("/"));
+
+  return (
+    <PaginatedTablePicker
+      breadcrumb={breadcrumb}
+      description={description}
+      queryKey={["memories", opts.region]}
+      loadPage={async (token, pageSize) => {
+        const response = await core.memory.listMemories(token, pageSize, opts);
+        return {
+          items: response.memories ?? [],
+          nextToken: response.nextToken,
+        };
+      }}
+      toRow={toRow}
+      columns={memoryColumns}
+      getValue={(row) => row.memoryId}
+      onSelect={onSelect}
+      onBack={goBack}
+      loadingMessage="Loading Memories..."
+      errorMessage={(error) => `Error: ${error.message}`}
+      emptyMessage="No Memories found in this Region."
+      emptyPageMessage="No Memories on this page."
+    />
+  );
+}

src/components/Root.tsx

@@ -32,6 +32,9 @@ import { MemoryScreen } from "../handlers/memory/screen.tsx";
 import { MemoryGetJsonScreen, MemoryGetScreen } from "../handlers/memory/get/screen.tsx";
 import { MemoryListScreen } from "../handlers/memory/list/screen.tsx";
 import { RuntimeInvokeScreen } from "../handlers/runtime/invoke/screen.tsx";
+import { MemoryEventScreen } from "../handlers/memory/event/screen.tsx";
+import { MemoryEventGetScreen } from "../handlers/memory/event/get/screen.tsx";
+import { MemoryEventListScreen } from "../handlers/memory/event/list/screen.tsx";
 import { RootScreen, HelpScreen } from "../handlers/screen.tsx";
 import type { Context } from "../router";
 
@@ -288,6 +291,34 @@ export function Root({ path, ctx, core, queryClient }: RootProps) {
             path="agentcore/runtime/invoke/:runtimeId/:qualifier"
             element={<RuntimeInvokeScreen ctx={ctx} core={core} />}
           />
+          <Route
+            path="agentcore/memory/event"
+            element={<MemoryEventScreen ctx={ctx} core={core} />}
+          />
+          <Route
+            path="agentcore/memory/event/get"
+            element={<Navigate to="/agentcore/memory/event/list" replace />}
+          />
+          <Route
+            path="agentcore/memory/event/get/:memoryId/:actorId/:sessionId/:eventId"
+            element={<MemoryEventGetScreen ctx={ctx} core={core} />}
+          />
+          <Route
+            path="agentcore/memory/event/list"
+            element={<MemoryEventListScreen ctx={ctx} core={core} />}
+          />
+          <Route
+            path="agentcore/memory/event/list/:memoryId"
+            element={<MemoryEventListScreen ctx={ctx} core={core} />}
+          />
+          <Route
+            path="agentcore/memory/event/list/:memoryId/:actorId"
+            element={<MemoryEventListScreen ctx={ctx} core={core} />}
+          />
+          <Route
+            path="agentcore/memory/event/list/:memoryId/:actorId/:sessionId"
+            element={<MemoryEventListScreen ctx={ctx} core={core} />}
+          />
           <Route path="*" element={<HelpScreen ctx={ctx} core={core} />} />
         </Routes>
       </MemoryRouter>

src/core/core.test.ts

@@ -10,8 +10,10 @@ import {
   InvokeAgentRuntimeCommand,
   InvokeAgentRuntimeCommandCommand,
   InvokeHarnessCommand,
+  ListActorsCommand,
   ListEventsCommand,
   ListMemoryRecordsCommand,
+  ListSessionsCommand,
   type BedrockAgentCoreClient,
 } from "@aws-sdk/client-bedrock-agentcore";
 import type { RuntimeInvokeRequest } from "../handlers/runtime/types";
@@ -244,6 +246,49 @@ test("listEvents sends a ListEventsCommand on the data client", async () => {
   expect((sent[0] as ListEventsCommand).input).toEqual(input);
 });
 
+test("listActors sends a ListActorsCommand on the data client", async () => {
+  const sent: unknown[] = [];
+  const response = { actorSummaries: [], nextToken: "next" };
+  const core = coreWithDataSend(async (command) => {
+    sent.push(command);
+    return response;
+  });
+  const input = {
+    memoryId: "memory-123",
+    maxResults: 25,
+    nextToken: "current",
+  };
+
+  const result = await core.memory.listActors(input, { region: "us-east-1" });
+
+  expect(result).toBe(response);
+  expect(sent).toHaveLength(1);
+  expect(sent[0]).toBeInstanceOf(ListActorsCommand);
+  expect((sent[0] as ListActorsCommand).input).toEqual(input);
+});
+
+test("listSessions sends a ListSessionsCommand on the data client", async () => {
+  const sent: unknown[] = [];
+  const response = { sessionSummaries: [], nextToken: "next" };
+  const core = coreWithDataSend(async (command) => {
+    sent.push(command);
+    return response;
+  });
+  const input = {
+    memoryId: "memory-123",
+    actorId: "actor-123",
+    maxResults: 25,
+    nextToken: "current",
+  };
+
+  const result = await core.memory.listSessions(input, { region: "us-east-1" });
+
+  expect(result).toBe(response);
+  expect(sent).toHaveLength(1);
+  expect(sent[0]).toBeInstanceOf(ListSessionsCommand);
+  expect((sent[0] as ListSessionsCommand).input).toEqual(input);
+});
+
 test("getMemoryRecord sends a GetMemoryRecordCommand on the data client", async () => {
   const sent: unknown[] = [];
   const response = { memoryRecord: undefined };

src/core/memory.tsx

@@ -1,16 +1,22 @@
 import {
   GetEventCommand,
   GetMemoryRecordCommand,
+  ListActorsCommand,
   ListEventsCommand,
   ListMemoryRecordsCommand,
+  ListSessionsCommand,
   type GetEventInput,
   type GetEventOutput,
   type GetMemoryRecordInput,
   type GetMemoryRecordOutput,
+  type ListActorsInput,
+  type ListActorsOutput,
   type ListEventsInput,
   type ListEventsOutput,
   type ListMemoryRecordsInput,
   type ListMemoryRecordsOutput,
+  type ListSessionsInput,
+  type ListSessionsOutput,
 } from "@aws-sdk/client-bedrock-agentcore";
 import {
   GetMemoryCommand,
@@ -46,6 +52,14 @@ export class MemoryClient implements CoreMemoryClient {
     return this.clients.data(toClientConfig(options)).send(new GetEventCommand(input));
   }
 
+  async listActors(input: ListActorsInput, options: CoreOptions): Promise<ListActorsOutput> {
+    return this.clients.data(toClientConfig(options)).send(new ListActorsCommand(input));
+  }
+
+  async listSessions(input: ListSessionsInput, options: CoreOptions): Promise<ListSessionsOutput> {
+    return this.clients.data(toClientConfig(options)).send(new ListSessionsCommand(input));
+  }
+
   async listEvents(input: ListEventsInput, options: CoreOptions): Promise<ListEventsOutput> {
     return this.clients.data(toClientConfig(options)).send(new ListEventsCommand(input));
   }