@redis-iris/agent-memory 0.3.1 → 0.4.0-beta.1

package/tests/new-api-contracts.test.mjs

@@ -0,0 +1,137 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { AgentMemory } from "../dist/esm/index.js";
+import { AgentMemoryCore } from "../dist/esm/core.js";
+import { listSessions } from "../dist/esm/funcs/list-sessions.js";
+import { HTTPClient } from "../dist/esm/lib/http.js";
+import { textToJSON } from "../dist/esm/models/content.js";
+import { ConflictErrorResponseContent } from "../dist/esm/models/errors/conflict-error-response-content.js";
+
+test("existing text content helpers remain available", () => {
+  assert.equal(textToJSON({ text: "hello" }), '{"text":"hello"}');
+});
+
+test("existing TypeScript session-listing calls compile unchanged", () => {
+  const require = createRequire(import.meta.url);
+  const result = spawnSync(process.execPath, [require.resolve("typescript/bin/tsc"),
+    "--noEmit", "--strict", "--module", "NodeNext", "--target", "ES2022",
+    fileURLToPath(new URL("list-sessions-compatibility.ts", import.meta.url)),
+  ], { encoding: "utf8" });
+  assert.equal(result.status, 0, result.stdout + result.stderr);
+});
+
+for (const standalone of [false, true]) {
+  test(`session listing preserves old arguments and new namespace filter (${standalone ? "standalone" : "SDK"})`, async () => {
+    const requests = [];
+    const client = new (standalone ? AgentMemoryCore : AgentMemory)({
+      serverURL: "https://example.test", storeId: "store-1",
+      httpClient: new HTTPClient({ fetcher: async (request) => {
+        requests.push(request);
+        return Response.json({ items: [], total: 0 });
+      } }),
+    });
+    const options = { serverURL: "https://override.test", headers: { "X-Request-ID": "compatibility" } };
+    const cases = [
+      { args: [], query: { limit: "100" } },
+      { args: [10, "next", "owner-1"], query: { limit: "10", pageToken: "next", filterOwnerId: "owner-1" } },
+      { args: [10, undefined, undefined, true], query: { limit: "10", includeAll: "true" } },
+      { args: [10, undefined, "owner-1", false, options], query: { limit: "10", filterOwnerId: "owner-1", includeAll: "false" } },
+      { args: [undefined, undefined, "owner-1", undefined, options], query: { limit: "100", filterOwnerId: "owner-1" } },
+      { args: [10, undefined, undefined, false, options, "namespace-1"], query: { limit: "10", includeAll: "false", namespaceRef: "namespace-1" } },
+    ];
+    for (const { args, query } of cases) {
+      const result = standalone ? await listSessions(client, ...args) : await client.listSessions(...args);
+      if (standalone) assert.equal(result.ok, true);
+      assert.deepEqual(standalone ? result.value : result, { items: [], total: 0 });
+      const request = requests.at(-1);
+      const url = new URL(request.url);
+      assert.equal(url.pathname, "/v1/stores/store-1/session-memory");
+      assert.deepEqual(Object.fromEntries(url.searchParams), query);
+      assert.equal(url.origin, args[4] ? "https://override.test" : "https://example.test");
+      assert.equal(request.headers.get("X-Request-ID"), args[4] ? "compatibility" : null);
+    }
+    assert.equal(requests.length, cases.length);
+  });
+}
+
+test("document content is base64 exactly once and acceptance retains Location", async () => {
+  const content = Buffer.from("Café customer prefers email.").toString("base64");
+  let calls = 0;
+  const body = { documentId: "doc-1", revision: "v1", content, mediaType: "text/plain",
+    ownerId: "owner-1", extractorId: "extractor-1", idempotencyKey: "submission-1" };
+  const sdk = new AgentMemory({ serverURL: "https://example.test", storeId: "store-1", apiKey: "test-key",
+    httpClient: new HTTPClient({ fetcher: async (request) => {
+      assert.equal(new URL(request.url).pathname, "/v1/stores/store-1/document-ingestions");
+      assert.equal(request.method, "POST");
+      assert.equal(request.headers.get("authorization"), "Bearer test-key");
+      assert.deepEqual(await request.json(), body);
+      if (++calls === 2) {
+        return Response.json({ title: "Conflict", type: "/errors/conflict", status: 409 }, { status: 409 });
+      }
+      return Response.json({ ingestionId: "ingestion-1", status: { processing: "queued", cleanup: "pending" } },
+        { status: 202, headers: { Location: "/ingestions/ingestion-1" } });
+    } }),
+  });
+  const accepted = await sdk.createDocumentIngestion(body);
+  assert.equal(accepted.result.ingestionId, "ingestion-1");
+  assert.equal(accepted.result.status.processing, "queued");
+  assert.deepEqual(accepted.headers.location, ["/ingestions/ingestion-1"]);
+  await assert.rejects(sdk.createDocumentIngestion(body), ConflictErrorResponseContent);
+});
+
+for (const value of [{ text: "Email preferred" }, { data: { count: 2, enabled: true } }]) {
+  test(`Summary View scope and ${"text" in value ? "text" : "structured"} result`, async () => {
+    const sdk = new AgentMemory({ serverURL: "https://example.test", storeId: "store-1",
+      httpClient: new HTTPClient({ fetcher: async (request) => {
+        const url = new URL(request.url);
+        assert.equal(request.method, "GET");
+        assert.equal(url.pathname, "/v1/stores/store-1/summary-views/view-1/result");
+        assert.deepEqual(Object.fromEntries(url.searchParams), { ownerId: "owner-1", includeSourceMemoryIds: "true" });
+        return Response.json({ viewId: "view-1", scope: { ownerId: "owner-1" }, status: "ready", stale: false,
+          format: "text" in value ? "text" : "structured", sourceMemoryCount: 2, summarizedMemoryCount: 2,
+          truncated: false, sourcesOmitted: false, sourceContentTruncated: false, definitionVersion: 1, value,
+          sourceMemoryIds: ["memory-1", "memory-2"], computedAt: "2026-09-30T12:00:00Z" });
+      } }),
+    });
+    const result = await sdk.getSummaryViewResult("view-1", "owner-1", undefined, undefined, undefined, true);
+    assert.deepEqual(result.value, value);
+    assert.deepEqual(result.sourceMemoryIds, ["memory-1", "memory-2"]);
+    assert.equal(result.computedAt.getUTCFullYear(), 2026);
+  });
+}
+
+test("summary result namespace scope and namespace list order stay compatible", async () => {
+  const requests = [];
+  const sdk = new AgentMemory({ serverURL: "https://example.test", storeId: "store-1",
+    httpClient: new HTTPClient({ fetcher: async (request) => {
+      requests.push(request);
+      const url = new URL(request.url);
+      if (url.pathname.endsWith("/result")) {
+        return Response.json({ viewId: "view-1", scope: { namespaceRef: "ns-1" }, status: "ready", stale: false,
+          format: "text", sourceMemoryCount: 1, summarizedMemoryCount: 1, truncated: false, sourcesOmitted: false,
+          sourceContentTruncated: false, definitionVersion: 1, value: { text: "ready" },
+          computedAt: "2026-10-02T12:00:00Z" });
+      }
+      if (url.pathname.endsWith("/namespaces")) return Response.json({ items: [] });
+      if (url.pathname.endsWith("/search")) {
+        assert.deepEqual(await request.json(), { sortBy: "createdAt", sortOrder: "asc", limit: 10 });
+        return Response.json({ items: [] });
+      }
+      throw new Error(url.pathname);
+    } }),
+  });
+  const options = { headers: { "X-Request-ID": "compatibility" } };
+  await sdk.getSummaryViewResult("view-1", undefined, undefined, "ns-1");
+  await sdk.listNamespaces(undefined, undefined, undefined, 10, "next", options);
+  await sdk.listNamespaces(undefined, undefined, undefined, 10, undefined, options, "name", "desc");
+  await sdk.searchLongTermMemory({ sortBy: "createdAt", sortOrder: "asc" });
+  const queries = requests.map((request) => Object.fromEntries(new URL(request.url).searchParams));
+  assert.deepEqual(queries[0], { namespaceRef: "ns-1" });
+  assert.deepEqual(queries[1], { limit: "10", pageToken: "next" });
+  assert.equal(requests[1].headers.get("X-Request-ID"), "compatibility");
+  assert.deepEqual(queries[2], { limit: "10", sortBy: "name", sortOrder: "desc" });
+  assert.equal(requests[2].headers.get("X-Request-ID"), "compatibility");
+});