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

package/src/sdk/sdk.ts

@@ -6,23 +6,41 @@
 import { addSessionEvent } from "../funcs/add-session-event.js";
 import { bulkCreateLongTermMemories } from "../funcs/bulk-create-long-term-memories.js";
 import { bulkDeleteLongTermMemories } from "../funcs/bulk-delete-long-term-memories.js";
+import { createDocumentIngestion } from "../funcs/create-document-ingestion.js";
 import { createNamespace } from "../funcs/create-namespace.js";
+import { createSummaryView } from "../funcs/create-summary-view.js";
 import { deleteNamespace } from "../funcs/delete-namespace.js";
 import { deleteSessionEvent } from "../funcs/delete-session-event.js";
 import { deleteSessionMemory } from "../funcs/delete-session-memory.js";
+import { deleteSummaryView } from "../funcs/delete-summary-view.js";
+import { getDocumentIngestion } from "../funcs/get-document-ingestion.js";
+import { getIngestionHookStatus } from "../funcs/get-ingestion-hook-status.js";
 import { getLongTermMemory } from "../funcs/get-long-term-memory.js";
+import { getNamespaceRouting } from "../funcs/get-namespace-routing.js";
 import { getNamespace } from "../funcs/get-namespace.js";
 import { getSessionEvent } from "../funcs/get-session-event.js";
 import { getSessionMemory } from "../funcs/get-session-memory.js";
+import { getSummaryViewResult } from "../funcs/get-summary-view-result.js";
+import { getSummaryView } from "../funcs/get-summary-view.js";
 import { health } from "../funcs/health.js";
+import { listDocumentIngestionOutputs } from "../funcs/list-document-ingestion-outputs.js";
+import { listIngestionHookStatuses } from "../funcs/list-ingestion-hook-statuses.js";
+import { listMemorySourceEvidence } from "../funcs/list-memory-source-evidence.js";
+import { listMemorySourceLinks } from "../funcs/list-memory-source-links.js";
 import { listNamespaces } from "../funcs/list-namespaces.js";
+import { listSessionSummaries } from "../funcs/list-session-summaries.js";
 import { listSessions } from "../funcs/list-sessions.js";
+import { listSourceMemories } from "../funcs/list-source-memories.js";
+import { listSummaryViews } from "../funcs/list-summary-views.js";
 import { moveLongTermMemories } from "../funcs/move-long-term-memories.js";
+import { putNamespaceRouting } from "../funcs/put-namespace-routing.js";
+import { refreshSummaryView } from "../funcs/refresh-summary-view.js";
 import { searchLongTermMemory } from "../funcs/search-long-term-memory.js";
 import { storeHealth } from "../funcs/store-health.js";
 import { updateLongTermMemoryFields } from "../funcs/update-long-term-memory-fields.js";
 import { updateLongTermMemory } from "../funcs/update-long-term-memory.js";
 import { updateNamespace } from "../funcs/update-namespace.js";
+import { updateSummaryView } from "../funcs/update-summary-view.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
@@ -41,6 +59,46 @@ export class AgentMemory extends ClientSDK {
     ));
   }
 
+  /**
+   * Submit one revisioned document for extraction.
+   */
+  async createDocumentIngestion(
+    request: models.CreateDocumentIngestionRequestContent,
+    options?: RequestOptions,
+  ): Promise<operations.CreateDocumentIngestionResponse> {
+    return unwrapAsync(createDocumentIngestion(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async getDocumentIngestion(
+    ingestionId: string,
+    options?: RequestOptions,
+  ): Promise<models.GetDocumentIngestionResponseContent> {
+    return unwrapAsync(getDocumentIngestion(
+      this,
+      ingestionId,
+      options,
+    ));
+  }
+
+  async listDocumentIngestionOutputs(
+    ingestionId: string,
+    limit?: number | undefined,
+    offset?: number | undefined,
+    options?: RequestOptions,
+  ): Promise<models.ListDocumentIngestionOutputsResponseContent> {
+    return unwrapAsync(listDocumentIngestionOutputs(
+      this,
+      ingestionId,
+      limit,
+      offset,
+      options,
+    ));
+  }
+
   /**
    * Returns read-only health for applicable store-scoped RAM features.
    */
@@ -55,6 +113,36 @@ export class AgentMemory extends ClientSDK {
     ));
   }
 
+  /**
+   * List hook decisions in stable newest-first order. Pages can be empty after owner filtering; continue while nextCursor is present. Internal run reservations are omitted.
+   */
+  async listIngestionHookStatuses(
+    limit?: number | undefined,
+    cursor?: string | undefined,
+    options?: RequestOptions,
+  ): Promise<models.ListIngestionHookStatusesResponseContent> {
+    return unwrapAsync(listIngestionHookStatuses(
+      this,
+      limit,
+      cursor,
+      options,
+    ));
+  }
+
+  /**
+   * Read a hook decision and application status. Requires authenticated store access and, when enforced, matching owner scope. Content and secrets are never returned.
+   */
+  async getIngestionHookStatus(
+    eventId: string,
+    options?: RequestOptions,
+  ): Promise<models.GetIngestionHookStatusResponseContent> {
+    return unwrapAsync(getIngestionHookStatus(
+      this,
+      eventId,
+      options,
+    ));
+  }
+
   /**
    * Deletes long-term memories in bulk by their IDs.
    */
@@ -70,7 +158,7 @@ export class AgentMemory extends ClientSDK {
   }
 
   /**
-   * Creates long-term memories in bulk.
+   * Creates long-term memories in bulk. Records without namespace or namespaceRef stay un-namespaced. Automatic routing does not place them in a shared namespace. An explicit namespaceRef must pass destination admission and is never rerouted. Admission failures are reported per record in errors.
    */
   async bulkCreateLongTermMemories(
     request: models.BulkCreateLongTermMemoriesRequestContent,
@@ -84,7 +172,7 @@ export class AgentMemory extends ClientSDK {
   }
 
   /**
-   * Moves long-term memories to one existing namespace resource. Returns 409 when the destination namespace is archived.
+   * Moves long-term memories to an explicit namespaceRef, or automatically routes a memory that is already in a shared namespace when namespaceRef is omitted. Personal and un-namespaced memories are not automatic-routing candidates and keep their current placement with a per-item error. If routing is disabled or no shared destination qualifies, the memory also keeps its current placement and receives a per-item error. An explicit destination must pass admission and is never rerouted. Returns 409 when the explicit destination is archived; automatic routing and admission failures are reported per item in errors.
    */
   async moveLongTermMemories(
     request: models.MoveLongTermMemoriesRequestContent,
@@ -126,7 +214,7 @@ export class AgentMemory extends ClientSDK {
   }
 
   /**
-   * Partially updates a long-term memory by its ID.
+   * Partially updates a long-term memory by its ID. The merged record must pass admission at its destination. Updates never select a different destination automatically.
    */
   async updateLongTermMemory(
     memoryId: string,
@@ -142,7 +230,7 @@ export class AgentMemory extends ClientSDK {
   }
 
   /**
-   * Atomically updates a custom-typed long-term memory's text and/or attributes, scoped to the caller's bound memory type. Used by the custom-extraction worker.
+   * Atomically updates a custom-typed long-term memory's text and/or attributes, scoped to the caller's bound memory type. Used by the custom-extraction worker. New text must pass destination admission before the update is applied.
    */
   async updateLongTermMemoryFields(
     memoryId: string,
@@ -157,6 +245,72 @@ export class AgentMemory extends ClientSDK {
     ));
   }
 
+  /**
+   * Pages source links for one long-term memory. Tokens bind this query and expire.
+   */
+  async listMemorySourceLinks(
+    memoryId: string,
+    limit?: number | undefined,
+    pageToken?: string | undefined,
+    options?: RequestOptions,
+  ): Promise<models.ListMemorySourceLinksResponseContent> {
+    return unwrapAsync(listMemorySourceLinks(
+      this,
+      memoryId,
+      limit,
+      pageToken,
+      options,
+    ));
+  }
+
+  /**
+   * Pages extraction evidence for one source of a memory, in append order. Tokens bind the store, current owner, memory and source, and expire.
+   */
+  async listMemorySourceEvidence(
+    memoryId: string,
+    sourceId: string,
+    limit?: number | undefined,
+    pageToken?: string | undefined,
+    options?: RequestOptions,
+  ): Promise<models.ListMemorySourceEvidenceResponseContent> {
+    return unwrapAsync(listMemorySourceEvidence(
+      this,
+      memoryId,
+      sourceId,
+      limit,
+      pageToken,
+      options,
+    ));
+  }
+
+  /**
+   * Returns the store's namespace routing policy. An empty disabled policy is returned when none has been saved.
+   */
+  async getNamespaceRouting(
+    request?: operations.GetNamespaceRoutingRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<models.GetNamespaceRoutingResponseContent> {
+    return unwrapAsync(getNamespaceRouting(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Replaces the store's namespace routing policy. Namespaces remain hierarchy records; routing is an ordered store-level document of plug-in strategies.
+   */
+  async putNamespaceRouting(
+    request: models.PutNamespaceRoutingRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.PutNamespaceRoutingResponseContent> {
+    return unwrapAsync(putNamespaceRouting(
+      this,
+      request,
+      options,
+    ));
+  }
+
   /**
    * Lists namespace roots or direct children.
    */
@@ -167,6 +321,8 @@ export class AgentMemory extends ClientSDK {
     limit?: number | undefined,
     pageToken?: string | undefined,
     options?: RequestOptions,
+    sortBy?: models.NamespaceSortBy | undefined,
+    sortOrder?: models.NamespaceSortOrder | undefined,
   ): Promise<models.ListNamespacesResponseContent> {
     return unwrapAsync(listNamespaces(
       this,
@@ -176,6 +332,8 @@ export class AgentMemory extends ClientSDK {
       limit,
       pageToken,
       options,
+      sortBy,
+      sortOrder,
     ));
   }
 
@@ -246,6 +404,7 @@ export class AgentMemory extends ClientSDK {
     filterOwnerId?: string | undefined,
     includeAll?: boolean | undefined,
     options?: RequestOptions,
+    namespaceRef?: string | undefined,
   ): Promise<models.ListSessionsResponseContent> {
     return unwrapAsync(listSessions(
       this,
@@ -254,6 +413,7 @@ export class AgentMemory extends ClientSDK {
       filterOwnerId,
       includeAll,
       options,
+      namespaceRef,
     ));
   }
 
@@ -332,4 +492,164 @@ export class AgentMemory extends ClientSDK {
       options,
     ));
   }
+
+  /**
+   * Returns paginated session rows with metadata and caller-selected order. The ID-only ListSessions operation remains unchanged.
+   */
+  async listSessionSummaries(
+    limit?: number | undefined,
+    pageToken?: string | undefined,
+    filterOwnerId?: string | undefined,
+    namespaceRef?: string | undefined,
+    includeAll?: boolean | undefined,
+    sortBy?: models.SessionListSortBy | undefined,
+    sortOrder?: models.SessionListSortOrder | undefined,
+    options?: RequestOptions,
+  ): Promise<models.ListSessionSummariesResponseContent> {
+    return unwrapAsync(listSessionSummaries(
+      this,
+      limit,
+      pageToken,
+      filterOwnerId,
+      namespaceRef,
+      includeAll,
+      sortBy,
+      sortOrder,
+      options,
+    ));
+  }
+
+  /**
+   * Pages memories linked to one source. A source link does not grant access to a memory in another owner or namespace.
+   */
+  async listSourceMemories(
+    sourceId: string,
+    ownerId: string,
+    limit?: number | undefined,
+    pageToken?: string | undefined,
+    options?: RequestOptions,
+  ): Promise<models.ListSourceMemoriesResponseContent> {
+    return unwrapAsync(listSourceMemories(
+      this,
+      sourceId,
+      ownerId,
+      limit,
+      pageToken,
+      options,
+    ));
+  }
+
+  /**
+   * Lists Summary View definitions and high-level state. Partition values are not included.
+   */
+  async listSummaryViews(
+    limit?: number | undefined,
+    pageToken?: string | undefined,
+    options?: RequestOptions,
+  ): Promise<models.ListSummaryViewsResponseContent> {
+    return unwrapAsync(listSummaryViews(
+      this,
+      limit,
+      pageToken,
+      options,
+    ));
+  }
+
+  /**
+   * Creates a Summary View definition and asynchronously enqueues its initial reconciliation.
+   */
+  async createSummaryView(
+    request: models.CreateSummaryViewRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.CreateSummaryViewResponseContent> {
+    return unwrapAsync(createSummaryView(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Marks a Summary View deleting and asynchronously removes its schedule and materializations in bounded batches. Repeated requests are idempotent.
+   */
+  async deleteSummaryView(
+    viewId: string,
+    options?: RequestOptions,
+  ): Promise<models.DeleteSummaryViewResponseContent> {
+    return unwrapAsync(deleteSummaryView(
+      this,
+      viewId,
+      options,
+    ));
+  }
+
+  /**
+   * Returns one Summary View definition without partition values.
+   */
+  async getSummaryView(
+    viewId: string,
+    options?: RequestOptions,
+  ): Promise<models.GetSummaryViewResponseContent> {
+    return unwrapAsync(getSummaryView(
+      this,
+      viewId,
+      options,
+    ));
+  }
+
+  /**
+   * Updates mutable Summary View fields. Source is immutable. Material changes increment definitionVersion; name- or description-only changes do not enqueue refresh work.
+   */
+  async updateSummaryView(
+    viewId: string,
+    body?: models.UpdateSummaryViewRequestContent | undefined,
+    options?: RequestOptions,
+  ): Promise<models.UpdateSummaryViewResponseContent> {
+    return unwrapAsync(updateSummaryView(
+      this,
+      viewId,
+      body,
+      options,
+    ));
+  }
+
+  /**
+   * Asynchronously enqueues one exact partition refresh or a complete view reconciliation. It never performs generation synchronously.
+   */
+  async refreshSummaryView(
+    viewId: string,
+    body: models.RefreshSummaryViewRequestContent,
+    options?: RequestOptions,
+  ): Promise<models.RefreshSummaryViewResponseContent> {
+    return unwrapAsync(refreshSummaryView(
+      this,
+      viewId,
+      body,
+      options,
+    ));
+  }
+
+  /**
+   * Returns one authorized exact Summary View partition after validating its contributing source records. Invalid output is withheld while repair is pending.
+   */
+  async getSummaryViewResult(
+    viewId: string,
+    ownerId?: string | undefined,
+    sessionId?: string | undefined,
+    namespaceRef?: string | undefined,
+    memoryType?: string | undefined,
+    includeSourceMemoryIds?: boolean | undefined,
+    options?: RequestOptions,
+  ): Promise<models.GetSummaryViewResultResponseContent> {
+    return unwrapAsync(getSummaryViewResult(
+      this,
+      viewId,
+      ownerId,
+      sessionId,
+      namespaceRef,
+      memoryType,
+      includeSourceMemoryIds,
+      options,
+    ));
+  }
 }

package/tests/list-sessions-compatibility.ts

@@ -0,0 +1,25 @@
+// Keep these pre-0.4 call shapes unchanged when regenerating the SDK.
+import { AgentMemory } from "../dist/esm/index.js";
+import { AgentMemoryCore } from "../dist/esm/core.js";
+import { listSessions } from "../dist/esm/funcs/list-sessions.js";
+import type { RequestOptions } from "../dist/esm/lib/sdks.js";
+
+declare const sdk: AgentMemory;
+declare const core: AgentMemoryCore;
+const options: RequestOptions = { headers: { "X-Request-ID": "compatibility" } };
+
+sdk.listSessions();
+sdk.listSessions(10, "next", "owner-1");
+sdk.listSessions(10, undefined, undefined, true);
+sdk.listSessions(10, undefined, "owner-1", false, options);
+sdk.listSessions(undefined, undefined, "owner-1", undefined, options);
+
+listSessions(core);
+listSessions(core, 10, "next", "owner-1");
+listSessions(core, 10, undefined, undefined, true);
+listSessions(core, 10, undefined, "owner-1", false, options);
+listSessions(core, undefined, undefined, "owner-1", undefined, options);
+
+// New namespace filtering leaves every existing argument in place.
+sdk.listSessions(10, undefined, undefined, false, options, "namespace-1");
+listSessions(core, 10, undefined, undefined, false, options, "namespace-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");
+});