@pentatonic-ai/ai-agent-sdk 0.10.10 → 0.10.12

package/dist/index.cjs

@@ -878,7 +878,7 @@ function fireAndForgetEmit(clientConfig, sessionOpts, messages, result, model) {
 }
 
 // src/telemetry.js
-var VERSION = "0.10.10";
+var VERSION = "0.10.12";
 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

@@ -847,7 +847,7 @@ function fireAndForgetEmit(clientConfig, sessionOpts, messages, result, model) {
 }
 
 // src/telemetry.js
-var VERSION = "0.10.10";
+var VERSION = "0.10.12";
 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.10.10",
+  "version": "0.10.12",
   "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-engine-v2/scripts/fusion_drive_fuse.py

@@ -56,12 +56,29 @@ def _distiller_post_fn(endpoint: str, model: str):
     """Build a post_fn(messages)->str hitting the distiller's OpenAI
     /v1/chat/completions (temperature 0, thinking off — same shape the worker
     uses). In-VPC: memory content never leaves the network. Raises on failure
-    so the adjudicator fails closed (treats it as 'unsure', never merges)."""
+    so the adjudicator fails closed (treats it as 'unsure', never merges).
+
+    Granular timeout: a short connect deadline so a scaled-to-zero distiller
+    fails in seconds, not 60s, but a generous read deadline so a live-but-busy
+    model still gets time to generate. Plus a circuit breaker — once a connect
+    fails, every later call short-circuits immediately, so a down distiller
+    costs one timeout for the whole run instead of one per candidate pair (the
+    autoscaler scales the distiller on the distill queue, not on fusion need,
+    so it is routinely down at sweep time)."""
+    timeout = httpx.Timeout(connect=5.0, read=60.0, write=10.0, pool=5.0)
+    state = {"down": False}
+
     def post(messages):
-        r = httpx.post(endpoint, timeout=60, json={
-            "model": model, "messages": messages, "temperature": 0.0,
-            "max_tokens": 120, "chat_template_kwargs": {"enable_thinking": False},
-        })
+        if state["down"]:
+            raise RuntimeError("distiller circuit open (earlier connect failed)")
+        try:
+            r = httpx.post(endpoint, timeout=timeout, json={
+                "model": model, "messages": messages, "temperature": 0.0,
+                "max_tokens": 120, "chat_template_kwargs": {"enable_thinking": False},
+            })
+        except (httpx.ConnectError, httpx.ConnectTimeout, httpx.ReadTimeout) as e:
+            state["down"] = True
+            raise RuntimeError(f"distiller unreachable: {e}") from e
         r.raise_for_status()
         return r.json()["choices"][0]["message"]["content"]
     return post
@@ -72,8 +89,23 @@ def _norm(s: str) -> str:
 
 
 def _entity_dup_sets(cur, arena: str) -> list[list[dict]]:
-    """Group same-(type) entities that are exact normalized-name dupes OR
-    share a provenance event with a junk-leaning twin. Returns groups of >=2."""
+    """Tier 1, DETERMINISTIC auto-merge: same-(type) entities whose names are
+    exact normalized-name dupes (case/whitespace variants like 'PR'/'pr',
+    'USDC'/'usdc', or two rows of the literally identical string). Returns
+    groups of >=2.
+
+    Co-occurrence (shared-provenance) is DELIBERATELY NOT here. A single event
+    routinely mentions a real entity AND a digit-heavy real entity that are
+    different things ("running Linux on the RTX 6000" — Linux and RTX 6000
+    share that event but are not the same node). looks_like_id flags any
+    digit-ratio>0.5 name as junk, which catches GPU models (RTX 6000, B2000),
+    protocol names (x402), and standards (EN18031) — all real. The legitimate
+    cross-run target ('1716801984' == 'Katie Cooper' across runs) is
+    INDISTINGUISHABLE from that false positive using only (type, shared-event,
+    digit-ratio), so co-occurrence merges CANNOT be made deterministically.
+    They are routed to the LLM-adjudicated tier (_cooccurrence_candidates) and
+    simply do not happen when the distiller is unreachable. (Was a Tier-1
+    auto-merge; the first prod dry-run merged RTX 6000→Linux, x402→USDC etc.)"""
     cur.execute(
         """SELECT id, entity_type, canonical_name, aliases, provenance_event_ids, disclosure_class
            FROM entities WHERE arena = %s AND disclosure_class <> 'restricted'""",
@@ -81,45 +113,10 @@ def _entity_dup_sets(cur, arena: str) -> list[list[dict]]:
     )
     ents = cur.fetchall()
     groups: dict[tuple, list[dict]] = {}
-    # 1. exact normalized-name within (type)
     for e in ents:
         key = (e["entity_type"], _norm(e["canonical_name"]))
         groups.setdefault(key, []).append(e)
-    exact = [g for g in groups.values() if len(g) > 1]
-
-    # 2. cross-run shared-provenance: same type + same event in provenance,
-    #    where some members are junk-leaning (looks-like-id) — catches
-    #    name-divergent dupes like "1716801984" vs "Katie Cooper" that never
-    #    block on name.
-    #
-    #    OVER-MERGE GUARD: a single event can legitimately mention several
-    #    distinct same-type entities (an email naming Alice, Bob, AND a
-    #    numeric-ID node). Merging the whole co-occurrence group would
-    #    conflate Alice and Bob. So the no-LLM tier ONLY proposes when the
-    #    group has EXACTLY ONE non-junk member: we fold the junk node(s) into
-    #    that unambiguous real master. Groups with 0 or >=2 non-junk members
-    #    are ambiguous and deferred to the LLM-adjudicated tier
-    #    (entity_resolution_v2.py) rather than auto-merged.
-    by_event_type: dict[tuple, list[dict]] = {}
-    for e in ents:
-        for ev in (e["provenance_event_ids"] or []):
-            by_event_type.setdefault((e["entity_type"], ev), []).append(e)
-    cross = []
-    seen_ids: set[str] = set()
-    for members in by_event_type.values():
-        if len(members) < 2:
-            continue
-        junk = [m for m in members if C.looks_like_id(m["canonical_name"])]
-        non_junk = [m for m in members if not C.looks_like_id(m["canonical_name"])]
-        if not junk or len(non_junk) != 1:
-            continue  # need junk to clean AND exactly one unambiguous master
-        group = non_junk + junk
-        ids = tuple(sorted(m["id"] for m in group))
-        if ids in seen_ids:
-            continue
-        seen_ids.add(ids)
-        cross.append(group)
-    return exact + cross
+    return [g for g in groups.values() if len(g) > 1]
 
 
 def _authority_signals(cur, arena: str, entity_ids: list[str], current_model: str) -> dict:
@@ -216,22 +213,33 @@ def _execute_entity_plan(cur, plan) -> None:
         cur.execute(
             """INSERT INTO entity_merges (id, arena, canonical_id, deprecated_id,
                  deprecated_canonical_name, deprecated_aliases, merge_signal,
-                 facts_repointed, rollback_payload)
-               VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s::jsonb)""",
+                 facts_repointed, relationships_repointed, merged_by, rollback_payload)
+               VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s::jsonb)""",
             ("em_" + uuid.uuid4().hex[:20], a["arena"], a["canonical_id"], a["deprecated_id"],
              a["deprecated_canonical_name"], a["deprecated_aliases"], a["merge_signal"],
              len(plan.fact_subject_repoints) + len(plan.fact_object_repoints),
+             len(plan.rel_endpoint_repoints), "fusion-drive",
              json.dumps(a["rollback_payload"], default=str)),
         )
     cur.execute("DELETE FROM entities WHERE id = ANY(%s)", (plan.deprecated_entity_ids,))
 
 
 def _dedup_master_facts(cur, arena: str, master_id: str) -> int:
-    """After repointing facts onto the master, the master can hold several
-    facts with the same (subject, predicate, object) but different statements
-    (fact id is content_id(arena, statement), so they didn't collapse on
-    insert). Fuse each such triple-group via build_fact_merge_plan: keep the
-    best, union provenance, delete dups with a fact_merges receipt."""
+    """After repointing facts onto the master, collapse facts that are now
+    TRUE duplicates — same (subject, predicate, object) AND the same normalized
+    statement. These exist because the fact id is content_id(arena, statement):
+    two rows with statements differing only in case/whitespace hash to distinct
+    ids and so survived insert-time dedup; once their subject/object entities
+    are unified they are genuinely the same assertion and fuse safely.
+
+    The statement is PART OF THE KEY on purpose. Grouping on the triple alone is
+    NOT identity: a NULL object with a generic predicate (e.g. subject "said"
+    NULL) buckets together unrelated assertions, and build_fact_merge_plan would
+    keep one and DELETE the rest — destroying distinct facts (it deleted 33% of
+    one arena's facts that way before this fix). Same-triple / different-meaning
+    facts are left untouched here; the LLM semantic tier (_semantic_fact_groups
+    + adjudicate_facts) is the only thing allowed to fuse facts whose statements
+    actually differ, and only on an affirmative same-assertion verdict."""
     cur.execute(
         """SELECT id, predicate, object_entity_id, statement, confidence, provenance_event_ids
            FROM facts
@@ -241,8 +249,12 @@ def _dedup_master_facts(cur, arena: str, master_id: str) -> int:
     rows = cur.fetchall()
     groups: dict[tuple, list[dict]] = {}
     for r in rows:
-        # group key uses the master as the subject anchor + predicate + object
-        groups.setdefault((master_id, r["predicate"], r["object_entity_id"]), []).append(r)
+        # key = master subject anchor + predicate + object + NORMALIZED STATEMENT.
+        # statement in the key => only byte-equal-after-normalization dupes fuse.
+        groups.setdefault(
+            (master_id, r["predicate"], r["object_entity_id"], _norm(r["statement"] or "")),
+            [],
+        ).append(r)
     deduped = 0
     for dup in groups.values():
         plan = build_fact_merge_plan(arena=arena, dup_facts=dup)
@@ -264,11 +276,19 @@ def _dedup_master_facts(cur, arena: str, master_id: str) -> int:
     return deduped
 
 
-def _ambiguous_cross_run(cur, arena: str) -> list[dict]:
-    """Co-occurrence groups the deterministic tier PUNTED on: a junk-leaning
-    node sharing an event with MULTIPLE non-junk candidates (so which real
-    entity it belongs to is ambiguous). Returns [{junk, candidates:[...]}] for
-    the LLM tier to adjudicate. Restricted disclosure excluded."""
+def _cooccurrence_candidates(cur, arena: str) -> list[dict]:
+    """ALL co-occurrence merge candidates — a junk-leaning node (looks_like_id)
+    sharing a provenance event with one OR more non-junk same-type nodes.
+    Returns [{junk, candidates:[...]}] for the LLM tier to adjudicate.
+
+    Co-occurrence is never sufficient evidence on its own (the deterministic
+    tier no longer auto-merges any of these — see _entity_dup_sets). Even the
+    single-candidate case ('1716801984' co-occurs with exactly one 'Katie
+    Cooper') must be confirmed by the adjudicator, because it's
+    indistinguishable from 'RTX 6000' co-occurring with exactly one 'Linux'.
+    The adjudicator merges only on an affirmative same-entity verdict and fails
+    closed (no merge) when the distiller is unreachable. Restricted disclosure
+    excluded."""
     cur.execute(
         """SELECT id, entity_type, canonical_name, aliases, provenance_event_ids
            FROM entities WHERE arena = %s AND disclosure_class <> 'restricted'""",
@@ -283,7 +303,7 @@ def _ambiguous_cross_run(cur, arena: str) -> list[dict]:
     for members in by_event_type.values():
         junk = [m for m in members if C.looks_like_id(m["canonical_name"])]
         non_junk = [m for m in members if not C.looks_like_id(m["canonical_name"])]
-        if not junk or len(non_junk) < 2:
+        if not junk or len(non_junk) < 1:
             continue
         for j in junk:
             key = (j["id"], tuple(sorted(c["id"] for c in non_junk)))
@@ -366,14 +386,17 @@ def main() -> int:
                 merged += len(loser_ids)
                 return len(loser_ids)
 
-            # Tier 1 — deterministic (exact-name + unambiguous cross-run)
+            # Tier 1 — deterministic: exact normalized-name dupes only
+            # (case/whitespace variants). Co-occurrence is NOT auto-merged.
             for group in _entity_dup_sets(cur, args.arena):
                 do_merge(group)
 
-            # Tier 2 — LLM adjudication via the in-VPC distiller (no egress)
+            # Tier 2 — LLM adjudication via the in-VPC distiller (no egress).
+            # ALL co-occurrence merges live here now — single- and multi-
+            # candidate alike — because co-occurrence never proves identity.
             if post_fn:
-                # 2a. ambiguous cross-run: which real entity does the junk match?
-                for amb in _ambiguous_cross_run(cur, args.arena):
+                # 2a. co-occurrence: does the junk node match a real entity?
+                for amb in _cooccurrence_candidates(cur, args.arena):
                     j = amb["junk"]
                     jctx = _entity_context(cur, args.arena, j["id"])
                     for cand in amb["candidates"]:

package/packages/memory-engine-v2/scripts/test_dedup_master_facts.py

@@ -0,0 +1,83 @@
+"""Guards _dedup_master_facts against the over-fusion that deleted 33% of an
+arena's facts (2026-06-14): grouping post-merge facts by (subject, predicate,
+object) alone treats a NULL object + generic predicate as identity and deletes
+distinct assertions. The statement must be part of the dedup key so ONLY
+byte-equal-after-normalization duplicates fuse; same-triple/different-meaning
+facts are left for the LLM semantic tier."""
+
+from __future__ import annotations
+
+import importlib
+import os
+import sys
+import types
+
+HERE = os.path.dirname(__file__)
+
+
+def _load_fuse(monkeypatch):
+    fake_psycopg = types.ModuleType("psycopg")
+    fake_rows = types.ModuleType("psycopg.rows")
+    fake_rows.dict_row = object()
+    fake_psycopg.rows = fake_rows
+    monkeypatch.setitem(sys.modules, "psycopg", fake_psycopg)
+    monkeypatch.setitem(sys.modules, "psycopg.rows", fake_rows)
+    monkeypatch.syspath_prepend(os.path.join(HERE, "..", "fusion_drive"))
+    monkeypatch.syspath_prepend(HERE)
+    sys.modules.pop("fusion_drive_fuse", None)
+    return importlib.import_module("fusion_drive_fuse")
+
+
+class FakeCursor:
+    """Returns preset fact rows on the SELECT; records ids passed to DELETE."""
+
+    def __init__(self, rows):
+        self._rows = rows
+        self.deleted_ids = []
+
+    def execute(self, sql, params=None):
+        s = " ".join(sql.split())
+        if s.startswith("DELETE FROM facts WHERE id = ANY"):
+            # params is a 1-tuple holding the id list
+            self.deleted_ids.extend(params[0])
+        # SELECT / UPDATE / INSERT: no-op (fetchall serves the preset rows)
+
+    def fetchall(self):
+        return self._rows
+
+
+def _fact(fid, predicate, obj, statement, conf):
+    return {
+        "id": fid,
+        "predicate": predicate,
+        "object_entity_id": obj,
+        "statement": statement,
+        "confidence": conf,
+        "provenance_event_ids": [f"ev_{fid}"],
+    }
+
+
+def test_distinct_statements_same_triple_are_NOT_fused(monkeypatch):
+    fuse = _load_fuse(monkeypatch)
+    rows = [
+        _fact("f1", "said", None, "Standing by", 0.9),
+        _fact("f2", "said", None, "yeah ship it", 0.8),       # distinct meaning
+        _fact("f3", "said", None, "modules/deep-memory is vestigial", 0.7),
+    ]
+    cur = FakeCursor(rows)
+    deleted = fuse._dedup_master_facts(cur, "arena", "m")
+    assert deleted == 0, "must not fuse same-triple facts with different statements"
+    assert cur.deleted_ids == []
+
+
+def test_only_normalized_statement_duplicates_fuse(monkeypatch):
+    fuse = _load_fuse(monkeypatch)
+    rows = [
+        _fact("f1", "said", None, "Standing by", 0.9),
+        _fact("f2", "said", None, "standing  by", 0.5),        # same after _norm
+        _fact("f3", "said", None, "something else entirely", 0.7),
+    ]
+    cur = FakeCursor(rows)
+    deleted = fuse._dedup_master_facts(cur, "arena", "m")
+    assert deleted == 1, "the case/whitespace duplicate should fuse"
+    assert cur.deleted_ids == ["f2"], "lower-confidence true-dupe is the one deleted"

package/packages/memory-engine-v2/scripts/test_distiller_post_fn.py

@@ -0,0 +1,70 @@
+"""Guards the distiller circuit breaker in fusion_drive_fuse._distiller_post_fn.
+
+When the distiller is scaled to zero (the autoscaler scales it on the distill
+queue, not on fusion need, so it is routinely down at sweep time) the first
+connect must fail fast AND open the circuit so every later candidate pair
+short-circuits instead of eating another connect timeout. A regression here
+reintroduces the >20min dry-run grind that motivated the fix."""
+
+from __future__ import annotations
+
+import importlib
+import os
+import sys
+import types
+
+import httpx
+import pytest
+
+HERE = os.path.dirname(__file__)
+
+
+def _load_fuse(monkeypatch):
+    # The script imports psycopg + adjudicate/canonical/merge at module level;
+    # stub psycopg (not installed in the unit env) and put the sibling package
+    # on the path so the real adjudicate/canonical/merge import cleanly.
+    fake_psycopg = types.ModuleType("psycopg")
+    fake_rows = types.ModuleType("psycopg.rows")
+    fake_rows.dict_row = object()
+    fake_psycopg.rows = fake_rows
+    monkeypatch.setitem(sys.modules, "psycopg", fake_psycopg)
+    monkeypatch.setitem(sys.modules, "psycopg.rows", fake_rows)
+    monkeypatch.syspath_prepend(os.path.join(HERE, "..", "fusion_drive"))
+    monkeypatch.syspath_prepend(HERE)
+    sys.modules.pop("fusion_drive_fuse", None)
+    return importlib.import_module("fusion_drive_fuse")
+
+
+def test_circuit_opens_after_first_connect_failure(monkeypatch):
+    fuse = _load_fuse(monkeypatch)
+    calls = {"n": 0}
+
+    def boom(*a, **k):
+        calls["n"] += 1
+        raise httpx.ConnectError("connection refused")
+
+    monkeypatch.setattr(httpx, "post", boom)
+    post = fuse._distiller_post_fn("http://10.0.0.1:8005/v1/chat/completions", "m")
+
+    with pytest.raises(RuntimeError, match="distiller unreachable"):
+        post([{"role": "user", "content": "a"}])
+    # second call must NOT hit the network again — circuit is open
+    with pytest.raises(RuntimeError, match="circuit open"):
+        post([{"role": "user", "content": "b"}])
+
+    assert calls["n"] == 1, "circuit breaker should make exactly one network attempt"
+
+
+def test_happy_path_returns_content(monkeypatch):
+    fuse = _load_fuse(monkeypatch)
+
+    class FakeResp:
+        def raise_for_status(self):
+            pass
+
+        def json(self):
+            return {"choices": [{"message": {"content": "yes"}}]}
+
+    monkeypatch.setattr(httpx, "post", lambda *a, **k: FakeResp())
+    post = fuse._distiller_post_fn("http://10.0.0.1:8005/v1/chat/completions", "m")
+    assert post([{"role": "user", "content": "a"}]) == "yes"