@redis-iris/agent-memory 1.0.0-beta.1 → 1.0.0-beta.2

package/tests/current-contracts.test.mjs

@@ -0,0 +1,91 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+const STORE = "st_" + "a".repeat(32);
+const BASE = `/iris/data/v1/agent-memory/stores/${STORE}`;
+
+for (const mode of ["esm", "commonjs"]) {
+  const sdkModule = mode === "esm" ? await import("../dist/esm/index.js") : require("../dist/commonjs/index.js");
+  const errors = mode === "esm" ? await import("../dist/esm/models/errors/index.js") : require("../dist/commonjs/models/errors/index.js");
+  const { AgentMemory, AgentMemoryService, HTTPClient } = sdkModule;
+
+  test(`${mode}: every published operation is available`, () => {
+    for (const [file, client] of [["openapi-agent-memory.json", AgentMemory],
+      ["openapi-agent-memory-controlplane.json", AgentMemoryService]]) {
+      const contract = JSON.parse(readFileSync(new URL(`../../${file}`, import.meta.url), "utf8"));
+      for (const item of Object.values(contract.paths)) {
+        for (const [method, operation] of Object.entries(item)) {
+          if (!["get", "post", "put", "patch", "delete"].includes(method)) continue;
+          const name = operation.operationId[0].toLowerCase() + operation.operationId.slice(1);
+          assert.equal(typeof client.prototype[name], "function", operation.operationId);
+        }
+      }
+    }
+  });
+
+  test(`${mode}: upsert, PATCH and typed field updates preserve revision and retry keys`, async () => {
+    const bodies = [
+      { text: "Prefers email", ownerId: "alice@example.com", attributes: { enabled: false }, expectedRevision: "r1", idempotencyKey: "upsert-1" },
+      { namespaceId: "ns_" + "b".repeat(32), expectedRevision: "r2", idempotencyKey: "patch-1" },
+      { memoryType: "preference", attributes: { count: 0 }, expectedRevision: "r3", idempotencyKey: "fields-1" },
+    ];
+    let calls = 0;
+    const sdk = new AgentMemory({ serverURL: "https://example.test", storeId: STORE, apiKey: "dp-token",
+      httpClient: new HTTPClient({ fetcher: async (request) => {
+        const i = calls++;
+        assert.equal(request.method, i === 0 ? "PUT" : "PATCH");
+        assert.equal(new URL(request.url).pathname, BASE + "/memories/memory-1" + (i === 2 ? "/fields" : ""));
+        assert.equal(request.headers.get("authorization"), "Bearer dp-token");
+        assert.deepEqual(await request.json(), bodies[i]);
+        return Response.json(i === 0 ? { memoryId: "memory-1", created: false } : i === 1
+          ? { memoryId: "memory-1", text: "Unchanged", revision: "r3", createdAt: "2026-10-30T12:00:00Z", updatedAt: "2026-10-30T13:00:00Z" } : {});
+      } }),
+    });
+    assert.deepEqual(await sdk.upsertLongTermMemory("memory-1", bodies[0]), { memoryId: "memory-1", created: false });
+    assert.equal((await sdk.updateLongTermMemory("memory-1", bodies[1])).revision, "r3");
+    await sdk.updateLongTermMemoryFields("memory-1", bodies[2]);
+    assert.equal(calls, 3);
+  });
+
+  test(`${mode}: memory-type deletion keeps CP credentials and revision query`, async () => {
+    const sdk = new AgentMemoryService({ serverURL: "https://example.test", token: "cp-token",
+      httpClient: new HTTPClient({ fetcher: async (request) => {
+        assert.equal(request.method, "DELETE");
+        const url = new URL(request.url);
+        assert.equal(url.pathname, `/iris/v1/agent-memory/stores/${STORE}/memory-types/preference`);
+        assert.deepEqual(Object.fromEntries(url.searchParams), { expectedRevision: "r1", projectId: "project-1" });
+        assert.equal(request.headers.get("authorization"), "Bearer cp-token");
+        return new Response(null, { status: 204 });
+      } }),
+    });
+    await sdk.removeMemoryType(STORE, "preference", "project-1", "r1");
+  });
+
+  for (const [status, errorName] of [[409, "ConflictErrorResponseContent"],
+    [412, "PreconditionFailedErrorResponseContent"], [413, "PayloadTooLargeErrorResponseContent"]]) {
+    test(`${mode}: HTTP ${status} keeps its typed error and unknown server reason`, async () => {
+      const sdk = new AgentMemory({ serverURL: "https://example.test", storeId: STORE,
+        httpClient: new HTTPClient({ fetcher: async () => Response.json({ title: "Rejected", type: "/errors/future-server-reason",
+          status, currentRevision: "r2" }, { status }) }),
+      });
+      await assert.rejects(sdk.upsertLongTermMemory("memory-1", { text: "test", ownerId: "alice@example.com", expectedRevision: "r1" }),
+        (error) => error instanceof errors[errorName] && error.type === "/errors/future-server-reason"
+          && (status !== 412 || error.currentRevision === "r2"));
+    });
+  }
+
+  for (const [Client, prefix] of [[AgentMemory, "/iris/data/v1"], [AgentMemoryService, "/iris/v1"]]) {
+    test(`${mode}: ${Client.name} health preserves future enum values`, async () => {
+      const sdk = new Client({ serverURL: "https://example.test", storeId: STORE,
+        httpClient: new HTTPClient({ fetcher: async (request) => {
+          assert.equal(new URL(request.url).pathname, prefix + "/agent-memory/health/live");
+          return Response.json({ status: "FUTURE_HEALTH_STATE" });
+        } }),
+      });
+      assert.equal((await sdk.getServiceLiveness()).status, "FUTURE_HEALTH_STATE");
+    });
+  }
+}