@pentatonic-ai/ai-agent-sdk 0.9.6 → 0.10.0

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

@@ -1,84 +0,0 @@
-"""Regression test for the L6 _embed_client shadowing bug introduced in v0.8.0.
-
-When the EmbedClient refactor landed in 0.8.0, the new `def _embed_client()`
-factory function was added at module top, but the legacy module-level
-`_embed_client = httpx.Client(timeout=60)` binding (used by Ollama entity
-extraction) was left in place. Python's top-to-bottom evaluation rebound
-the name to the httpx.Client instance, so any subsequent call to
-`_embed_client()` raised `TypeError: 'Client' object is not callable`.
-
-This silently 500'd every L6 /index-batch and /search request from 0.8.0
-through 0.8.2 — the bug couldn't be caught by /health because the process
-itself stays up, only the request handlers fail.
-
-This is a static-source test (parses the file) rather than an import-time
-test because L6's heavy imports (pymilvus, spacy) aren't available in the
-unit-test venv. The check: scan the AST for any non-function rebinding of
-identifiers that are also defined as `def` in the same module. Catches
-this exact bug shape across any service that uses the EmbedClient factory
-pattern.
-"""
-
-from __future__ import annotations
-
-import ast
-from pathlib import Path
-
-import pytest
-
-SERVICES_DIR = Path(__file__).parent.parent / "engine" / "services"
-
-# Services that use the lazy EmbedClient factory pattern.
-SERVICES_WITH_EMBED_FACTORY = [
-    SERVICES_DIR / "l4" / "server.py",
-    SERVICES_DIR / "l5" / "l5-comms-layer.py",
-    SERVICES_DIR / "l6" / "l6-document-store.py",
-    SERVICES_DIR / "l2" / "l2-hybridrag-proxy.py",
-]
-
-
-def _module_level_defs_and_assigns(source: str) -> tuple[set[str], set[str]]:
-    """Return (function names, non-function-assigned names) at module level."""
-    tree = ast.parse(source)
-    funcs: set[str] = set()
-    assigns: set[str] = set()
-    for node in tree.body:
-        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            funcs.add(node.name)
-        elif isinstance(node, ast.Assign):
-            for target in node.targets:
-                if isinstance(target, ast.Name):
-                    assigns.add(target.id)
-        elif isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name):
-            assigns.add(node.target.id)
-    return funcs, assigns
-
-
-@pytest.mark.parametrize("service_file", SERVICES_WITH_EMBED_FACTORY, ids=lambda p: f"{p.parent.name}/{p.name}")
-def test_no_module_level_shadowing_of_factory_functions(service_file: Path):
-    """A module-level `def foo()` must not also have a module-level `foo = ...`
-    later in the file. That's exactly the shape that caused the v0.8.0 L6 bug."""
-    source = service_file.read_text()
-    funcs, assigns = _module_level_defs_and_assigns(source)
-    overlap = funcs & assigns
-    assert not overlap, (
-        f"{service_file.relative_to(SERVICES_DIR.parent.parent)} has module-level "
-        f"identifier(s) defined as both `def` and `name = ...`: {sorted(overlap)}. "
-        f"This causes silent name shadowing — the assignment wins and any call "
-        f"to {sorted(overlap)[0]}() raises TypeError at runtime."
-    )
-
-
-def test_l6_uses_renamed_ollama_http_not_embed_client():
-    """Belt-and-suspenders: explicitly assert L6's Ollama HTTP client is at
-    `_ollama_http`, not `_embed_client`. If someone reintroduces the original
-    binding by accident, this test catches it without depending on AST traversal."""
-    source = (SERVICES_DIR / "l6" / "l6-document-store.py").read_text()
-    assert "_embed_client = httpx.Client" not in source, (
-        "L6 reintroduced the legacy `_embed_client = httpx.Client(...)` binding "
-        "that shadowed the EmbedClient factory in v0.8.0. Rename to _ollama_http."
-    )
-    assert "_ollama_http = httpx.Client" in source, (
-        "L6 is missing the renamed Ollama HTTP client (`_ollama_http = httpx.Client(...)`). "
-        "The Ollama entity-extraction call path needs an httpx.Client somewhere."
-    )

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

@@ -1,432 +0,0 @@
-"""Integration tests for the /people-list-internal endpoint.
-
-Sister file to ``test_channel_stat_reader.py``: that one covers
-``aggregate_internal`` (per-person aggregate); this one covers
-``people_list_internal`` (corpus-level aggregate — one row per
-Person across one or more arenas).
-
-The endpoint backs the Pip Relationships UI list page. Where
-``aggregate_internal`` returns the per-channel breakdown FOR one
-person, ``people_list_internal`` returns one row PER PERSON across
-the whole arena set, with the per-channel breakdown nested.
-
-Gated on NEO4J_TEST_URI + NEO4J_TEST_PASSWORD; skip cleanly when
-those env vars are absent so unit-only test runs stay fast.
-
-Run:
-
-    cd packages/memory-engine
-    NEO4J_TEST_URI=bolt://localhost:17687 \\
-    NEO4J_TEST_PASSWORD=testpassword \\
-    .venv/bin/python -m pytest tests/test_people_list_reader.py -v
-"""
-from __future__ import annotations
-
-import asyncio
-import importlib.util
-import os
-import sys
-import uuid
-from pathlib import Path
-
-import pytest
-
-
-_NEO4J_URI = os.environ.get("NEO4J_TEST_URI")
-_NEO4J_USER = os.environ.get("NEO4J_TEST_USER", "neo4j")
-_NEO4J_PASSWORD = os.environ.get("NEO4J_TEST_PASSWORD")
-
-_skip_no_neo4j = pytest.mark.skipif(
-    not (_NEO4J_URI and _NEO4J_PASSWORD),
-    reason="set NEO4J_TEST_URI + NEO4J_TEST_PASSWORD to run integration tests",
-)
-
-
-ENGINE_ROOT = Path(__file__).resolve().parent.parent / "engine" / "services" / "l2"
-sys.path.insert(0, str(ENGINE_ROOT))
-
-
-@pytest.fixture(scope="module")
-def proxy_module():
-    """Mirror of the helper in test_channel_stat_reader.py — load
-    l2-hybridrag-proxy as a module so we can call the FastAPI handler
-    directly without HTTP. Override NEO4J_URI/NEO4J_AUTH at runtime
-    rather than at import time."""
-    spec = importlib.util.spec_from_file_location(
-        "l2_proxy_module",
-        ENGINE_ROOT / "l2-hybridrag-proxy.py",
-    )
-    assert spec and spec.loader
-    try:
-        mod = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(mod)
-    except ImportError:
-        pytest.skip("l2 proxy deps unavailable in this venv (fine for unit-only runs)")
-    mod.NEO4J_URI = _NEO4J_URI
-    mod.NEO4J_AUTH = (_NEO4J_USER, _NEO4J_PASSWORD)
-    return mod
-
-
-@pytest.fixture
-def neo4j_driver():
-    """Per-test driver + cleanup. Three arenas so multi-arena tests
-    have something to span across."""
-    from neo4j import GraphDatabase
-
-    driver = GraphDatabase.driver(_NEO4J_URI, auth=(_NEO4J_USER, _NEO4J_PASSWORD))
-    arenas = [
-        f"pl_a_{uuid.uuid4().hex[:8]}",
-        f"pl_b_{uuid.uuid4().hex[:8]}",
-        f"pl_c_{uuid.uuid4().hex[:8]}",
-    ]
-    yield driver, arenas
-    with driver.session() as session:
-        for arena in arenas:
-            session.run(
-                "MATCH (n) WHERE n.arena = $arena DETACH DELETE n",
-                arena=arena,
-            )
-    driver.close()
-
-
-def _ensure_indexes(session) -> None:
-    """Idempotent index + constraint setup matching the writer block."""
-    session.run(
-        "CREATE INDEX channelstat_arena_email IF NOT EXISTS "
-        "FOR (s:ChannelStat) ON (s.arena, s.person_email)"
-    )
-    session.run(
-        "CREATE CONSTRAINT channelstat_unique IF NOT EXISTS "
-        "FOR (s:ChannelStat) REQUIRE (s.arena, s.person_email, s.channel) IS UNIQUE"
-    )
-
-
-def _write_stat(
-    session,
-    arena: str,
-    email: str,
-    channel: str,
-    count: int = 1,
-    inbound: int = 0,
-    outbound: int = 0,
-    last_seen: str = "2026-05-10T00:00:00Z",
-    first_seen: str = "2024-01-01T00:00:00Z",
-    name: str | None = None,
-) -> None:
-    """Insert a ChannelStat node + matching Person (with optional
-    name). Skips the Chunk + COMMUNICATED edge — those aren't read
-    by ``people_list_internal`` since it reads the denorm directly."""
-    session.run(
-        """
-        MERGE (s:ChannelStat {arena: $arena, person_email: $email, channel: $channel})
-        SET s.count = $count,
-            s.inbound = $inbound,
-            s.outbound = $outbound,
-            s.last_seen = $last_seen,
-            s.first_seen = $first_seen
-        """,
-        arena=arena, email=email, channel=channel,
-        count=count, inbound=inbound, outbound=outbound,
-        last_seen=last_seen, first_seen=first_seen,
-    )
-    # Person node carries the display name. Email is the join key.
-    # OPTIONAL MATCH in the reader joins on email + arena.
-    session.run(
-        """
-        MERGE (p:Entity:Person {arena: $arena, email: $email})
-        SET p.name = $name
-        """,
-        arena=arena, email=email, name=name,
-    )
-
-
-def _call_people_list(proxy_module, **kwargs):
-    """Invoke people_list_internal directly. Same shape as
-    _call_aggregate in the sister file."""
-    req = proxy_module.PeopleListInternalRequest(**kwargs)
-    return asyncio.run(proxy_module.people_list_internal(req))
-
-
-# ---------------------------------------------------------------------------
-# Single-arena basic behaviour.
-# ---------------------------------------------------------------------------
-
-
-@_skip_no_neo4j
-def test_returns_one_row_per_person_with_channels_nested(
-    neo4j_driver, proxy_module
-) -> None:
-    """Three ChannelStats for two people in one arena → two list rows.
-    Channels collapse into the nested ``channels`` list per person."""
-    driver, (arena, _, _) = neo4j_driver
-    with driver.session() as session:
-        _ensure_indexes(session)
-        # Alex: email + slack
-        _write_stat(session, arena, "alex@x.io", "email", count=3, inbound=2, outbound=1,
-                    last_seen="2026-05-10T00:00:00Z", name="Alex Tong")
-        _write_stat(session, arena, "alex@x.io", "slack", count=1, inbound=1, outbound=0,
-                    last_seen="2026-05-08T00:00:00Z", name="Alex Tong")
-        # Bea: email only
-        _write_stat(session, arena, "bea@y.io", "email", count=5, inbound=5, outbound=0,
-                    last_seen="2026-05-09T00:00:00Z", name="Bea Chen")
-
-    out = _call_people_list(proxy_module, arenas=[arena])
-    assert out.total_count == 2
-    assert out.has_more is False
-    emails = sorted(item.person_email for item in out.items)
-    assert emails == ["alex@x.io", "bea@y.io"]
-    alex = next(item for item in out.items if item.person_email == "alex@x.io")
-    assert alex.person_name == "Alex Tong"
-    assert alex.total == 4  # 3 email + 1 slack
-    assert alex.inbound == 3
-    assert alex.outbound == 1
-    assert alex.last_seen == "2026-05-10T00:00:00Z"
-    assert {ch.channel for ch in alex.channels} == {"email", "slack"}
-
-
-@_skip_no_neo4j
-def test_default_order_is_last_seen_desc(neo4j_driver, proxy_module) -> None:
-    """Default sort: most-recently-active person first. Backs the
-    Relationships UI's default landing view."""
-    driver, (arena, _, _) = neo4j_driver
-    with driver.session() as session:
-        _ensure_indexes(session)
-        _write_stat(session, arena, "old@x.io", "email", last_seen="2025-01-01T00:00:00Z")
-        _write_stat(session, arena, "new@x.io", "email", last_seen="2026-05-12T00:00:00Z")
-        _write_stat(session, arena, "mid@x.io", "email", last_seen="2026-01-01T00:00:00Z")
-
-    out = _call_people_list(proxy_module, arenas=[arena])
-    assert [i.person_email for i in out.items] == ["new@x.io", "mid@x.io", "old@x.io"]
-
-
-# ---------------------------------------------------------------------------
-# Multi-arena behaviour.
-# ---------------------------------------------------------------------------
-
-
-@_skip_no_neo4j
-def test_multi_arena_returns_persons_from_both_arenas(
-    neo4j_driver, proxy_module
-) -> None:
-    """A vendor who appears in arena A AND arena B should be one row
-    with both arenas' channel data. Backs the "people known by Philip
-    OR Jeanne" use case."""
-    driver, (arena_a, arena_b, _) = neo4j_driver
-    with driver.session() as session:
-        _ensure_indexes(session)
-        # Same vendor in both arenas
-        _write_stat(session, arena_a, "vendor@v.io", "email", count=2,
-                    last_seen="2026-05-10T00:00:00Z", name="Vendor Co")
-        _write_stat(session, arena_b, "vendor@v.io", "slack", count=3,
-                    last_seen="2026-05-11T00:00:00Z", name="Vendor Co")
-        # Unique-to-A person
-        _write_stat(session, arena_a, "only@a.io", "email", last_seen="2026-05-09T00:00:00Z")
-
-    out = _call_people_list(proxy_module, arenas=[arena_a, arena_b])
-    emails = sorted(i.person_email for i in out.items)
-    assert emails == ["only@a.io", "vendor@v.io"]
-    vendor = next(i for i in out.items if i.person_email == "vendor@v.io")
-    # Total across both arenas
-    assert vendor.total == 5
-    # Both channels surface
-    assert {ch.channel for ch in vendor.channels} == {"email", "slack"}
-    # last_seen is the max across arenas
-    assert vendor.last_seen == "2026-05-11T00:00:00Z"
-
-
-@_skip_no_neo4j
-def test_arena_filter_excludes_other_arenas(neo4j_driver, proxy_module) -> None:
-    """A person in arena C must NOT appear when only A+B are requested."""
-    driver, (arena_a, arena_b, arena_c) = neo4j_driver
-    with driver.session() as session:
-        _ensure_indexes(session)
-        _write_stat(session, arena_a, "a-only@x.io", "email")
-        _write_stat(session, arena_c, "c-only@x.io", "email")
-
-    out = _call_people_list(proxy_module, arenas=[arena_a, arena_b])
-    emails = {i.person_email for i in out.items}
-    assert "a-only@x.io" in emails
-    assert "c-only@x.io" not in emails
-
-
-# ---------------------------------------------------------------------------
-# Filters.
-# ---------------------------------------------------------------------------
-
-
-@_skip_no_neo4j
-def test_emails_filter_restricts_to_listed_addresses(
-    neo4j_driver, proxy_module
-) -> None:
-    """``emails`` is the batched-mode filter — used by Pip's nightly
-    health-recompute to fetch facets for many specific people in one
-    call. Cuts 8k×9 SQL queries to ~9 GraphQL calls."""
-    driver, (arena, _, _) = neo4j_driver
-    with driver.session() as session:
-        _ensure_indexes(session)
-        _write_stat(session, arena, "alex@x.io", "email")
-        _write_stat(session, arena, "bea@y.io", "email")
-        _write_stat(session, arena, "carl@z.io", "email")
-
-    out = _call_people_list(
-        proxy_module,
-        arenas=[arena],
-        emails=["alex@x.io", "carl@z.io"],
-    )
-    emails = sorted(i.person_email for i in out.items)
-    assert emails == ["alex@x.io", "carl@z.io"]
-
-
-@_skip_no_neo4j
-def test_search_substring_matches_email_or_name(
-    neo4j_driver, proxy_module
-) -> None:
-    """Search is case-insensitive substring on person_name and
-    person_email. Backs the Relationships UI search box."""
-    driver, (arena, _, _) = neo4j_driver
-    with driver.session() as session:
-        _ensure_indexes(session)
-        _write_stat(session, arena, "alex@pentatonic.com", "email", name="Alex Tong")
-        _write_stat(session, arena, "bea@pentatonic.com", "email", name="Bea Chen")
-        _write_stat(session, arena, "carl@external.com", "email", name="Carl X")
-
-    # Search by name fragment
-    out = _call_people_list(proxy_module, arenas=[arena], search="alex")
-    assert {i.person_email for i in out.items} == {"alex@pentatonic.com"}
-
-    # Search by email-domain fragment matches everyone at pentatonic
-    out = _call_people_list(proxy_module, arenas=[arena], search="pentatonic")
-    assert {i.person_email for i in out.items} == {
-        "alex@pentatonic.com", "bea@pentatonic.com",
-    }
-
-
-@_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.
-# ---------------------------------------------------------------------------
-
-
-@_skip_no_neo4j
-def test_pagination_limit_and_offset(neo4j_driver, proxy_module) -> None:
-    """`limit` slices the page; `total_count` is the unfiltered count
-    BEFORE pagination so the UI can render "Showing N of M"."""
-    driver, (arena, _, _) = neo4j_driver
-    with driver.session() as session:
-        _ensure_indexes(session)
-        # 5 people, last_seen ascending so a desc sort puts e first
-        for i, letter in enumerate("abcde"):
-            _write_stat(
-                session, arena, f"{letter}@x.io", "email",
-                last_seen=f"2026-05-{10 + i:02d}T00:00:00Z",
-            )
-
-    page1 = _call_people_list(proxy_module, arenas=[arena], limit=2, offset=0)
-    page2 = _call_people_list(proxy_module, arenas=[arena], limit=2, offset=2)
-    page3 = _call_people_list(proxy_module, arenas=[arena], limit=2, offset=4)
-    assert page1.total_count == 5 == page2.total_count == page3.total_count
-    assert page1.has_more is True
-    assert page2.has_more is True
-    assert page3.has_more is False
-    assert [i.person_email for i in page1.items] == ["e@x.io", "d@x.io"]
-    assert [i.person_email for i in page2.items] == ["c@x.io", "b@x.io"]
-    assert [i.person_email for i in page3.items] == ["a@x.io"]
-
-
-@_skip_no_neo4j
-def test_order_by_total_desc(neo4j_driver, proxy_module) -> None:
-    driver, (arena, _, _) = neo4j_driver
-    with driver.session() as session:
-        _ensure_indexes(session)
-        _write_stat(session, arena, "many@x.io", "email", count=100)
-        _write_stat(session, arena, "few@x.io", "email", count=5)
-        _write_stat(session, arena, "mid@x.io", "email", count=50)
-
-    out = _call_people_list(proxy_module, arenas=[arena], order_by="total_desc")
-    assert [i.person_email for i in out.items] == [
-        "many@x.io", "mid@x.io", "few@x.io",
-    ]
-
-
-# ---------------------------------------------------------------------------
-# Validation.
-# ---------------------------------------------------------------------------
-
-
-@_skip_no_neo4j
-def test_empty_arenas_list_rejected(neo4j_driver, proxy_module) -> None:
-    """An empty arenas list should 400, not silently return everything.
-    Multi-tenant safety: a missing/empty filter must not become an
-    'all tenants' query."""
-    from fastapi import HTTPException
-
-    with pytest.raises(HTTPException) as exc:
-        _call_people_list(proxy_module, arenas=[])
-    assert exc.value.status_code == 400
-
-
-@_skip_no_neo4j
-def test_unknown_order_by_rejected(neo4j_driver, proxy_module) -> None:
-    """Whitelisted sort keys — anything else 400s. Belt-and-braces
-    against ORDER BY templating becoming an injection vector."""
-    from fastapi import HTTPException
-
-    driver, (arena, _, _) = neo4j_driver
-    with pytest.raises(HTTPException) as exc:
-        _call_people_list(
-            proxy_module, arenas=[arena],
-            order_by="totally_made_up",
-        )
-    assert exc.value.status_code == 400