@pentatonic-ai/ai-agent-sdk 0.9.0 → 0.9.2

package/dist/index.cjs

@@ -906,7 +906,7 @@ function fireAndForgetEmit(clientConfig, sessionOpts, messages, result, model) {
 }
 
 // src/telemetry.js
-var VERSION = "0.9.0";
+var VERSION = "0.9.2";
 var TELEMETRY_URL = "https://sdk-telemetry.philip-134.workers.dev";
 function machineId() {
   const raw = typeof process !== "undefined" ? `${process.env?.USER || process.env?.USERNAME || "u"}:${process.platform || "x"}:${process.arch || "x"}` : "browser";

package/dist/index.js

@@ -875,7 +875,7 @@ function fireAndForgetEmit(clientConfig, sessionOpts, messages, result, model) {
 }
 
 // src/telemetry.js
-var VERSION = "0.9.0";
+var VERSION = "0.9.2";
 var TELEMETRY_URL = "https://sdk-telemetry.philip-134.workers.dev";
 function machineId() {
   const raw = typeof process !== "undefined" ? `${process.env?.USER || process.env?.USERNAME || "u"}:${process.platform || "x"}:${process.arch || "x"}` : "browser";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pentatonic-ai/ai-agent-sdk",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "TES SDK — LLM observability and lifecycle tracking via Pentatonic Thing Event System. Track token usage, tool calls, and conversations. Manage things through event-sourced lifecycle stages with AI enrichment and vector search.",
   "type": "module",
   "main": "./dist/index.cjs",

package/packages/memory/src/__tests__/engine.test.js

@@ -2,6 +2,7 @@ import { describe, it, expect, beforeEach, jest } from "@jest/globals";
 import {
   fetchEngine,
   engineStore,
+  engineStoreBatch,
   engineSearch,
   engineAggregate,
   enginePeopleList,
@@ -170,6 +171,129 @@ describe("engine HTTP client", () => {
     });
   });
 
+  describe("engineStoreBatch", () => {
+    it("posts to /store-batch with arena fixed per-record", async () => {
+      mockOk({ status: "ok", inserted: 2, ids: ["a1", "a2"] });
+      await engineStoreBatch("https://e", {
+        clientId: "acme",
+        records: [
+          { content: "first", metadata: { kind: "note" } },
+          { content: "second", metadata: { kind: "doc" } },
+        ],
+        layerType: "episodic",
+        actorUserId: "u-1",
+      });
+      const body = JSON.parse(calls[0].init.body);
+      expect(calls[0].url).toBe("https://e/store-batch");
+      expect(body).toEqual({
+        records: [
+          {
+            content: "first",
+            metadata: {
+              kind: "note",
+              arena: "acme",
+              layer_type: "episodic",
+              actor_user_id: "u-1",
+            },
+          },
+          {
+            content: "second",
+            metadata: {
+              kind: "doc",
+              arena: "acme",
+              layer_type: "episodic",
+              actor_user_id: "u-1",
+            },
+          },
+        ],
+      });
+    });
+
+    it("user-scoped arena applies to every record when userId provided", async () => {
+      mockOk({ status: "ok", inserted: 3, ids: ["a", "b", "c"] });
+      await engineStoreBatch("https://e", {
+        clientId: "acme",
+        userId: "user-42",
+        records: [
+          { content: "a" },
+          { content: "b" },
+          { content: "c" },
+        ],
+      });
+      const body = JSON.parse(calls[0].init.body);
+      for (const r of body.records) {
+        expect(r.metadata.arena).toBe("acme:user-42");
+      }
+    });
+
+    it("passes explicit per-record id through unchanged", async () => {
+      mockOk({ status: "ok", inserted: 1, ids: ["custom-id"] });
+      await engineStoreBatch("https://e", {
+        clientId: "acme",
+        records: [{ id: "custom-id", content: "x" }],
+      });
+      const body = JSON.parse(calls[0].init.body);
+      expect(body.records[0].id).toBe("custom-id");
+      expect(body.records[0].content).toBe("x");
+    });
+
+    it("omits id when not provided so engine hashes the content", async () => {
+      mockOk({ status: "ok", inserted: 1, ids: ["server-hashed"] });
+      await engineStoreBatch("https://e", {
+        clientId: "acme",
+        records: [{ content: "x" }],
+      });
+      const body = JSON.parse(calls[0].init.body);
+      expect(body.records[0]).not.toHaveProperty("id");
+    });
+
+    it("does NOT let caller override arena via per-record metadata", async () => {
+      mockOk({ status: "ok", inserted: 1, ids: ["x"] });
+      await engineStoreBatch("https://e", {
+        clientId: "acme",
+        records: [
+          { content: "x", metadata: { arena: "tenant-b" } },
+        ],
+      });
+      const body = JSON.parse(calls[0].init.body);
+      expect(body.records[0].metadata.arena).toBe("acme");
+    });
+
+    it("returns early without HTTP call when records is empty", async () => {
+      mockOk({ status: "ok", inserted: 0, ids: [] });
+      const out = await engineStoreBatch("https://e", {
+        clientId: "acme",
+        records: [],
+      });
+      expect(out).toEqual({ status: "ok", inserted: 0, ids: [] });
+      expect(calls.length).toBe(0);
+    });
+
+    it("rejects missing clientId", async () => {
+      await expect(
+        engineStoreBatch("https://e", { records: [{ content: "x" }] })
+      ).rejects.toThrow(/clientId/);
+    });
+
+    it("rejects non-array records", async () => {
+      await expect(
+        engineStoreBatch("https://e", { clientId: "a" })
+      ).rejects.toThrow(/records/);
+      await expect(
+        engineStoreBatch("https://e", { clientId: "a", records: "oops" })
+      ).rejects.toThrow(/records/);
+    });
+
+    it("rejects non-string content with the offending index", async () => {
+      await expect(
+        engineStoreBatch("https://e", {
+          clientId: "a",
+          records: [{ content: "ok" }, { content: 123 }],
+        })
+      ).rejects.toThrow(/records\[1\]\.content/);
+    });
+  });
+
   describe("engineSearch", () => {
     it("tenant-only arenas list when no userId", async () => {
       mockOk({ results: [] });

package/packages/memory/src/engine.js

@@ -206,6 +206,75 @@ export async function engineStore(engineUrl, opts) {
   return fetchEngine(engineUrl, "/store", body, { headers });
 }
 
+/**
+ * Batch-store many records in one engine call.
+ *
+ * One HTTP round-trip → engine issues one batched embed call covering
+ * every record (vs N round-trips + N single-text embeds for `engineStore`).
+ * Per `/store-batch` semantics, the response includes per-record ids
+ * plus the engine block with per-layer write counts.
+ *
+ * Arena composition matches `engineStore`: tenant-wide
+ * (`arena = clientId`) by default, user-scoped (`arena = clientId:userId`)
+ * when `userId` is supplied, overridable via `scope`. The shared arena
+ * is applied to **every** record; per-record `metadata` is preserved
+ * but cannot override the SDK-fixed arena (last-spread-wins ordering).
+ *
+ * Each record may carry an explicit `id` (stable dedup key) or omit
+ * it and let the engine hash the content. Per-record `metadata` is
+ * merged with the shared layerType / actorUserId before posting.
+ *
+ * @param {string} engineUrl
+ * @param {object} opts
+ * @param {string}  opts.clientId
+ * @param {string}  [opts.userId]
+ * @param {"tenant"|"user"} [opts.scope]
+ * @param {Array<{content: string, metadata?: object, id?: string}>} opts.records
+ * @param {string}  [opts.layerType]
+ * @param {string}  [opts.actorUserId]
+ * @param {Record<string,string>} [opts.headers]
+ * @returns {Promise<{status: string, inserted: number, ids: string[], engine?: object, duration_ms?: number}>}
+ */
+export async function engineStoreBatch(engineUrl, opts) {
+  const {
+    clientId,
+    userId,
+    scope,
+    records,
+    layerType,
+    actorUserId,
+    headers,
+  } = opts || {};
+  if (!clientId) throw new Error("engineStoreBatch: clientId required");
+  if (!Array.isArray(records)) {
+    throw new Error("engineStoreBatch: records[] required");
+  }
+  // Short-circuit empty input — no network round-trip, no error.
+  // Matches engineStore's tolerance for trivial inputs at upstream callers.
+  if (records.length === 0) {
+    return { status: "ok", inserted: 0, ids: [] };
+  }
+  const arena = composeArena(clientId, userId, scope);
+  const body = {
+    records: records.map((r, i) => {
+      if (typeof r?.content !== "string") {
+        throw new Error(`engineStoreBatch: records[${i}].content must be a string`);
+      }
+      return {
+        ...(r.id ? { id: r.id } : {}),
+        content: r.content,
+        metadata: {
+          ...(r.metadata || {}),
+          arena,
+          ...(layerType ? { layer_type: layerType } : {}),
+          ...(actorUserId !== undefined ? { actor_user_id: actorUserId } : {}),
+        },
+      };
+    }),
+  };
+  return fetchEngine(engineUrl, "/store-batch", body, { headers });
+}
+
 /**
  * Search the engine, scoped to a tenant.
  *

package/packages/memory-engine/engine/services/_shared/embed_provider.py

@@ -211,6 +211,7 @@ class EmbedClient:
         autodetect: bool = True,
         timeout: float = 120.0,
         env_prefix: str = "",
+        max_batch: int = 5,
     ) -> None:
         self._configured_provider = provider
         self._provider = provider
@@ -222,6 +223,12 @@ class EmbedClient:
         self._autodetect = autodetect
         self._env_prefix = env_prefix
         self._detected = False
+        # 0 = unlimited (no chunking). Positive = max texts per upstream call;
+        # larger inputs are split into multiple calls (concurrent in async path)
+        # and the results concatenated. Defaults to 5 because that's the per-call
+        # cap observed on Pentatonic AI Gateway — above which it 502s and the
+        # caller silently loses vector writes (see test_chunking_* tests).
+        self._max_batch = max(0, max_batch)
 
     # ------------------------------------------------------------------
     # Construction
@@ -248,6 +255,7 @@ class EmbedClient:
           {prefix}EMBED_PROVIDER     default 'openai'
           {prefix}EMBED_AUTODETECT   default 'true'
           {prefix}EMBED_TIMEOUT      default '120'
+          {prefix}EMBED_MAX_BATCH    default '5' (gateway-safe; '0' disables chunking)
         """
         url_var = url_var or f"{prefix}NV_EMBED_URL"
         key_var = key_var or f"{prefix}EMBED_API_KEY"
@@ -259,6 +267,7 @@ class EmbedClient:
         provider_name = os.environ.get(f"{prefix}EMBED_PROVIDER", "openai")
         autodetect = os.environ.get(f"{prefix}EMBED_AUTODETECT", "true").lower() == "true"
         timeout = float(os.environ.get(f"{prefix}EMBED_TIMEOUT", "120"))
+        max_batch = int(os.environ.get(f"{prefix}EMBED_MAX_BATCH", "5"))
 
         provider = resolve_provider(provider_name, env_prefix=prefix)
         return cls(
@@ -269,6 +278,7 @@ class EmbedClient:
             autodetect=autodetect,
             timeout=timeout,
             env_prefix=prefix,
+            max_batch=max_batch,
         )
 
     # ------------------------------------------------------------------
@@ -307,10 +317,21 @@ class EmbedClient:
     # ------------------------------------------------------------------
 
     def embed_batch(self, texts: list[str]) -> list[list[float]]:
-        """Embed a list of texts. Empty list returns empty list."""
+        """Embed a list of texts. Empty list returns empty list.
+
+        Splits into chunks of `max_batch` (default 5) and posts each
+        sequentially when the input exceeds the limit. Results are
+        concatenated in input order. `max_batch=0` disables chunking.
+        """
         if not texts:
             return []
-        return self._post_with_autodetect(texts, async_mode=False)
+        if self._max_batch == 0 or len(texts) <= self._max_batch:
+            return self._post_with_autodetect(texts, async_mode=False)
+        out: list[list[float]] = []
+        for start in range(0, len(texts), self._max_batch):
+            chunk = texts[start:start + self._max_batch]
+            out.extend(self._post_with_autodetect(chunk, async_mode=False))
+        return out
 
     def embed_one(self, text: str) -> list[float]:
         return self.embed_batch([text])[0]
@@ -320,9 +341,25 @@ class EmbedClient:
     # ------------------------------------------------------------------
 
     async def embed_batch_async(self, texts: list[str]) -> list[list[float]]:
+        """Async embed. Chunks are fired concurrently via asyncio.gather
+        when the input exceeds `max_batch`; raises the first error if any
+        chunk fails (matching the un-chunked semantics)."""
         if not texts:
             return []
-        return await self._post_with_autodetect_async(texts)
+        if self._max_batch == 0 or len(texts) <= self._max_batch:
+            return await self._post_with_autodetect_async(texts)
+        import asyncio
+        chunks = [
+            texts[start:start + self._max_batch]
+            for start in range(0, len(texts), self._max_batch)
+        ]
+        results = await asyncio.gather(
+            *(self._post_with_autodetect_async(chunk) for chunk in chunks)
+        )
+        out: list[list[float]] = []
+        for r in results:
+            out.extend(r)
+        return out
 
     async def embed_one_async(self, text: str) -> list[float]:
         out = await self.embed_batch_async([text])

package/packages/memory-engine/engine/services/l2/l2-hybridrag-proxy.py

@@ -2362,22 +2362,20 @@ async def people_list_internal(
                 email_filter_clause = " AND s.person_email IN $emails"
                 params["emails"] = emails_filter
 
-            search_clause = ""
             if search_pattern:
-                # Match against person_email; person_name is resolved
-                # via the OPTIONAL MATCH on Person below, so we can't
-                # apply it inside the initial WHERE without joining first.
-                # Two-step: filter on email here, then re-filter after
-                # joining the Person. (Works at our scale; revisit if
-                # we ever need search to scale to 10k+ people.)
-                search_clause = " AND toLower(s.person_email) CONTAINS $search"
+                # Defer the whole search filter until after the Person
+                # join — person_name only exists after the OPTIONAL
+                # MATCH below. Pre-filtering ChannelStats on email
+                # alone (the earlier two-step approach) silently dropped
+                # name-only matches, e.g. email=ag@x.io / name="Alex
+                # Tong" with search="alex" — the early WHERE failed and
+                # the post-join filter never saw the row.
                 params["search"] = search_pattern
 
             cypher = (
                 "MATCH (s:ChannelStat)\n"
                 "WHERE s.arena IN $arenas"
                 + email_filter_clause
-                + search_clause
                 + "\n"
                 "WITH s.person_email AS person_email,\n"
                 "     collect({channel: s.channel, count: s.count,\n"
@@ -2393,11 +2391,17 @@ async def people_list_internal(
                 "WITH person_email,\n"
                 "     channels,\n"
                 "     head(collect(DISTINCT p.name)) AS person_name\n"
-                # Apply the name-side of the search filter now that we
-                # have the joined name.
+                # Apply the search filter now that we have both the
+                # joined name and the email available. `coalesce(name,
+                # '')` keeps people without a Person node in the result
+                # set when their email matches — they fall through the
+                # name probe cleanly instead of bypassing the filter
+                # via a `person_name IS NULL` short-circuit, which was
+                # the prior bug (anyone without a Person node passed
+                # search regardless of term).
                 + (
-                    "WHERE ($search IS NULL OR person_name IS NULL OR toLower(person_name) CONTAINS $search\n"
-                    "       OR toLower(person_email) CONTAINS $search)\n"
+                    "WHERE toLower(coalesce(person_name, '')) CONTAINS $search\n"
+                    "       OR toLower(person_email) CONTAINS $search\n"
                     if search_pattern
                     else ""
                 )

package/packages/memory-engine/tests/test_embed_provider.py

@@ -352,3 +352,141 @@ def test_url_without_path_gets_provider_default(recorder):
     )
     client.embed_batch(["x"])
     assert recorder.calls[0]["url"] == "https://lambda-gateway.pentatonic.com/v1/embed"
+
+
+# ----------------------------------------------------------------------
+# Chunking — work around the Pentatonic AI Gateway's per-call cap of 5
+# texts. Above the cap the gateway 502s; without chunking the layer's
+# /index-batch handler raises, the compat shim swallows it, and vector
+# writes silently drop. Chunking splits the request into chunks of
+# `max_batch` so each call stays within the gateway's limit.
+# ----------------------------------------------------------------------
+
+
+class _PentatonicEchoStub:
+    """httpx.post replacement that returns one embedding per input text,
+    matching real gateway behaviour. Each response embedding encodes the
+    input index so tests can assert order preservation across chunks."""
+
+    def __init__(self):
+        self.calls: list[dict] = []
+        self._offset = 0  # running input-index counter across calls
+
+    def __call__(self, url, *, json, headers, timeout):
+        self.calls.append({"url": url, "json": json, "headers": headers, "timeout": timeout})
+        n = len(json.get("input") or [])
+        embs = [[float(self._offset + i)] for i in range(n)]
+        self._offset += n
+        return _FakeResponse(200, {"embeddings": embs})
+
+
+def test_chunking_below_max_batch_makes_one_call(monkeypatch):
+    """N <= max_batch sends one request, no chunking overhead."""
+    stub = _PentatonicEchoStub()
+    monkeypatch.setattr(httpx, "post", stub)
+    client = EmbedClient(
+        url="https://lambda-gateway.pentatonic.com/v1/embed",
+        api_key="k", model="m",
+        provider=PROVIDERS["pentatonic-gateway"],
+        max_batch=5,
+    )
+    out = client.embed_batch([f"t{i}" for i in range(5)])
+    assert len(out) == 5
+    assert len(stub.calls) == 1
+    assert len(stub.calls[0]["json"]["input"]) == 5
+
+
+def test_chunking_above_max_batch_splits_into_calls(monkeypatch):
+    """N > max_batch is split into len(N)/max_batch posts; results are
+    concatenated in input order so the caller can't tell."""
+    stub = _PentatonicEchoStub()
+    monkeypatch.setattr(httpx, "post", stub)
+    client = EmbedClient(
+        url="https://lambda-gateway.pentatonic.com/v1/embed",
+        api_key="k", model="m",
+        provider=PROVIDERS["pentatonic-gateway"],
+        max_batch=5,
+    )
+    out = client.embed_batch([f"t{i}" for i in range(12)])
+    # 12 texts → chunks of [5, 5, 2] → 3 calls
+    assert len(stub.calls) == 3
+    assert [len(c["json"]["input"]) for c in stub.calls] == [5, 5, 2]
+    # Stub returns one vector per input. Each vector encodes its
+    # cross-chunk input index → assert order preserved.
+    assert len(out) == 12
+    assert out == [[float(i)] for i in range(12)]
+
+
+def test_chunking_disabled_with_max_batch_zero(monkeypatch):
+    """max_batch=0 means no chunking — old behaviour (one big call)."""
+    stub = _PentatonicEchoStub()
+    monkeypatch.setattr(httpx, "post", stub)
+    client = EmbedClient(
+        url="https://lambda-gateway.pentatonic.com/v1/embed",
+        api_key="k", model="m",
+        provider=PROVIDERS["pentatonic-gateway"],
+        max_batch=0,
+    )
+    client.embed_batch([f"t{i}" for i in range(20)])
+    assert len(stub.calls) == 1
+    assert len(stub.calls[0]["json"]["input"]) == 20
+
+
+def test_chunking_propagates_first_error(recorder):
+    """If a chunk fails (e.g., gateway 502), the whole call raises with
+    the first error — matching the un-chunked semantics. We don't return
+    a partial vector list because the caller's downstream `for r, emb, txt
+    in zip(...)` loop would silently drop the failed records."""
+    # Pentatonic gateway 502 on every call (simulates the real bug)
+    recorder.respond(
+        "https://lambda-gateway.pentatonic.com/v1/embed",
+        _FakeResponse(502, "<html>...bad gateway...</html>"),
+    )
+    client = EmbedClient(
+        url="https://lambda-gateway.pentatonic.com/v1/embed",
+        api_key="k", model="m",
+        provider=PROVIDERS["pentatonic-gateway"],
+        max_batch=5,
+    )
+    with pytest.raises(EmbedHTTPError) as exc:
+        client.embed_batch([f"t{i}" for i in range(8)])
+    assert exc.value.status == 502
+
+
+class _OpenAIEchoStub:
+    """OpenAI-shaped stub: returns one embedding per input as
+    {data: [{embedding: [...]}]}."""
+
+    def __init__(self):
+        self.calls: list[dict] = []
+
+    def __call__(self, url, *, json, headers, timeout):
+        self.calls.append({"url": url, "json": json, "headers": headers, "timeout": timeout})
+        n = len(json.get("input") or [])
+        return _FakeResponse(200, {"data": [{"embedding": [0.0]} for _ in range(n)]})
+
+
+def test_from_env_reads_max_batch(monkeypatch):
+    """{prefix}EMBED_MAX_BATCH overrides the default of 5."""
+    monkeypatch.setenv("L4_NV_EMBED_URL", "https://gw/v1/embeddings")
+    monkeypatch.setenv("L4_EMBED_API_KEY", "k")
+    monkeypatch.setenv("L4_EMBED_MAX_BATCH", "3")
+    stub = _OpenAIEchoStub()
+    monkeypatch.setattr(httpx, "post", stub)
+    client = EmbedClient.from_env(prefix="L4_")
+    client.embed_batch([f"t{i}" for i in range(7)])
+    # 7 with chunk=3 → [3, 3, 1] → 3 calls
+    assert len(stub.calls) == 3
+    assert [len(c["json"]["input"]) for c in stub.calls] == [3, 3, 1]
+
+
+def test_from_env_default_max_batch_is_five(monkeypatch):
+    """Default max_batch=5 matches the observed Pentatonic Gateway cap."""
+    monkeypatch.setenv("L4_NV_EMBED_URL", "https://gw/v1/embeddings")
+    monkeypatch.setenv("L4_EMBED_API_KEY", "k")
+    stub = _OpenAIEchoStub()
+    monkeypatch.setattr(httpx, "post", stub)
+    client = EmbedClient.from_env(prefix="L4_")
+    client.embed_batch([f"t{i}" for i in range(10)])
+    # 10 with default chunk=5 → [5, 5] → 2 calls
+    assert len(stub.calls) == 2

package/packages/memory-engine/tests/test_people_list_reader.py

@@ -301,6 +301,59 @@ def test_search_substring_matches_email_or_name(
     }
 
 
+@_skip_no_neo4j
+def test_search_matches_name_when_email_does_not(
+    neo4j_driver, proxy_module
+) -> None:
+    """Regression: an early-WHERE on ``ChannelStat`` filtered rows by
+    email-only before the Person join, so a person whose NAME matched
+    the search term but whose EMAIL didn't was silently dropped. Fixed
+    by deferring the whole search filter until after the OPTIONAL MATCH
+    on Person. Sentinel case: email ``ag@x.io`` / name ``Alex Tong`` /
+    search ``alex`` — must match on name even though email has no
+    substring overlap."""
+    driver, (arena, _, _) = neo4j_driver
+    with driver.session() as session:
+        _ensure_indexes(session)
+        _write_stat(session, arena, "ag@x.io", "email", name="Alex Tong")
+        _write_stat(session, arena, "other@x.io", "email", name="Bea Chen")
+
+    out = _call_people_list(proxy_module, arenas=[arena], search="alex")
+    assert {i.person_email for i in out.items} == {"ag@x.io"}
+
+
+@_skip_no_neo4j
+def test_search_does_not_bypass_filter_when_person_node_missing(
+    neo4j_driver, proxy_module
+) -> None:
+    """Regression: the previous WHERE clause had a ``person_name IS
+    NULL`` short-circuit that bypassed the search filter for anyone
+    without a Person node — they matched any search term. Fixed by
+    using ``coalesce(person_name, '')`` so the name probe just fails
+    cleanly when no Person record exists, falling through to the email
+    probe."""
+    driver, (arena, _, _) = neo4j_driver
+    with driver.session() as session:
+        _ensure_indexes(session)
+        # Insert a ChannelStat WITHOUT a Person node — simulates a
+        # contact who's been emailed but never had a Person record
+        # materialised. Use a raw write so _write_stat's MERGE doesn't
+        # auto-create a Person.
+        session.run(
+            "MERGE (s:ChannelStat {arena: $arena, person_email: $email, channel: 'email'}) "
+            "SET s.count = 1, s.inbound = 1, s.outbound = 0, "
+            "    s.last_seen = '2026-05-10T00:00:00Z', "
+            "    s.first_seen = '2026-05-10T00:00:00Z'",
+            arena=arena, email="orphan@x.io",
+        )
+        _write_stat(session, arena, "alex@x.io", "email", name="Alex Tong")
+
+    # Search "alex" must NOT match orphan@x.io — neither name (missing)
+    # nor email contains "alex".
+    out = _call_people_list(proxy_module, arenas=[arena], search="alex")
+    assert {i.person_email for i in out.items} == {"alex@x.io"}
+
+
 # ---------------------------------------------------------------------------
 # Pagination.
 # ---------------------------------------------------------------------------