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

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.11";
 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.11";
 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.11",
   "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:
@@ -264,11 +261,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 +288,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 +371,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_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"