@pentatonic-ai/ai-agent-sdk 0.10.27 → 0.10.29

package/dist/index.cjs

@@ -878,7 +878,7 @@ function fireAndForgetEmit(clientConfig, sessionOpts, messages, result, model) {
 }
 
 // src/telemetry.js
-var VERSION = "0.10.27";
+var VERSION = "0.10.29";
 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.27";
+var VERSION = "0.10.29";
 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.27",
+  "version": "0.10.29",
   "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/extractor-async/worker.py

@@ -121,6 +121,16 @@ STUDENT_API_KEY = os.environ.get("STUDENT_API_KEY", "")
 STUDENT_MODEL = os.environ.get("STUDENT_MODEL", "nuextract-2.0-4b-ft")
 STUDENT_TIMEOUT_SEC = float(os.environ.get("STUDENT_TIMEOUT_SEC", "60"))
 STUDENT_MAX_TOKENS = int(os.environ.get("STUDENT_MAX_TOKENS", "768"))
+# Student-path concurrency — SEPARATE from CONCURRENT_LLM_CALLS. That knob is
+# tuned for the teacher (N concurrent 27B *batch* calls of EVENTS_PER_LLM_CALL
+# events each); the cascade reused it to bound student calls, throttling a 4B
+# model — which batches 30–60 single-event calls at <5% KV cache on an L4 — to
+# just 6/worker. Under a bursty backlog that left the student GPU-pinned but
+# starved (Running:1, Waiting:0, KV:0.1%; 25k-backlog incident 2026-07-08). Each
+# student call is ONE event (tiny KV), so it parallelises far higher. Tune per
+# the box's KV-cache headroom. Do NOT raise CONCURRENT_LLM_CALLS to fix student
+# throughput — that also raises teacher 27B concurrency (OOM risk).
+STUDENT_CONCURRENT_CALLS = int(os.environ.get("STUDENT_CONCURRENT_CALLS", "48"))
 # Fraction of student-passing events ALSO sent to the teacher — NOT a quality
 # lever, this is the monitoring + active-learning sample (drift detection and
 # fresh teacher-gold on live traffic). Default conservative-ish 5%.
@@ -2649,7 +2659,10 @@ async def _process_cascade(
     gates: a pass writes the student's extraction (producer='student'); a fail/
     sample escalates to the teacher. Disjoint — the student writes XOR the event
     is escalated, so there is nothing to supersede."""
-    sem = asyncio.Semaphore(CONCURRENT_LLM_CALLS)
+    # STUDENT_CONCURRENT_CALLS, not CONCURRENT_LLM_CALLS: the student is a cheap
+    # single-event 4B call that batches far higher than the teacher's 27B
+    # batch-calls (see the config note). Reusing the teacher knob starved it.
+    sem = asyncio.Semaphore(STUDENT_CONCURRENT_CALLS)
 
     async def _student(item):
         async with sem:
@@ -2792,70 +2805,91 @@ def _apply_extraction(
     det_ents, det_rels = structured_graph_elements(arena, event.get("attributes"))
 
     try:
-        name_to_id = upsert_entities(
-            conn, arena, event_id, participant_set, disclosure, ents + det_ents,
-            event_time, event.get("attributes"),
-        )
-        n_facts = upsert_facts(
-            conn, arena, event_id, participant_set, disclosure, facts, name_to_id,
-            event_time, due_at, src,
-        )
-        n_rels = upsert_relationships(
-            conn, arena, event_id, participant_set, disclosure, rels + det_rels, name_to_id,
-            event_time,
-        )
-        mark_done(conn, queue_id)
-        log.info(
-            f"completed queue_id={queue_id} event_id={event_id} producer={producer} "
-            f"entities={len(name_to_id)} facts={n_facts} relationships={n_rels}"
-            f" det_edges={len(det_rels)}"
-            + (f" llm_ms={llm_ms:.0f}" if not stub_mode and llm_ms else "")
-        )
-        # Trace logging — best-effort. ONLY the teacher produces training gold;
-        # logging student output would train the student on itself.
-        if DISTILL_TRACE_ENABLED and not stub_mode and producer == "teacher":
-            try:
-                _insert_trace(
-                    conn,
-                    event_id=event_id,
-                    user_prompt=build_event_block(local_idx, event),
-                    raw_response=result.get("raw_slice", ""),
-                    llm_chunk_ms=llm_ms,
-                )
-            except Exception as trace_exc:
-                log.warning(
-                    f"trace insert failed queue_id={queue_id} "
-                    f"event_id={event_id}: {trace_exc}"
-                )
-        # Cascade ledger — best-effort, records which producer wrote this
-        # event's rows (only when the cascade is on).
-        if CASCADE_ENABLED:
-            try:
-                _record_distillation(
-                    conn,
-                    event_id=event_id,
-                    producer=producer,
-                    llm_model=LLM_MODEL if producer == "teacher" else STUDENT_MODEL,
-                    escalated=escalated,
-                    escalate_reason=escalate_reason,
-                )
-            except Exception as ledger_exc:
-                log.warning(
-                    f"ledger insert failed queue_id={queue_id} "
-                    f"event_id={event_id}: {ledger_exc}"
-                )
-        return True
+        # ONE transaction per event. The connection is autocommit (amain), so
+        # without this each statement fsync-commits on its own — ~20 commits per
+        # event (entity resolution SELECTs/locks/upserts + facts + rels +
+        # mark_done), which is the round-trip bottleneck under a backlog: the
+        # graph PG sits idle between the worker's serial commits (profiled
+        # 2026-07-08 — 39 conns idle, 1 active). Wrapping commits once per event.
+        #
+        # NB: this also makes upsert_entities' `pg_advisory_xact_lock` actually
+        # span the event's resolution. Under autocommit each lock released after
+        # its own single-statement txn — effectively a NO-OP — so the
+        # per-surface-form anti-fragmentation lock never protected the
+        # SELECT-overlap→INSERT window. Now it holds for the whole event: correct
+        # (the lock finally does its job), but it serialises concurrent workers
+        # that touch the same surface form. Load-test before trusting on prod.
+        with conn.transaction():
+            name_to_id = upsert_entities(
+                conn, arena, event_id, participant_set, disclosure, ents + det_ents,
+                event_time, event.get("attributes"),
+            )
+            n_facts = upsert_facts(
+                conn, arena, event_id, participant_set, disclosure, facts, name_to_id,
+                event_time, due_at, src,
+            )
+            n_rels = upsert_relationships(
+                conn, arena, event_id, participant_set, disclosure, rels + det_rels, name_to_id,
+                event_time,
+            )
+            mark_done(conn, queue_id)
     except Exception as exc:
         err = f"{type(exc).__name__}: {exc}"
         log.warning(
             f"db upsert failed queue_id={queue_id} attempts={attempts}: {err}"
         )
+        # The transaction rolled back; the claim bookkeeping runs on the
+        # now-autocommit connection so it persists independently.
         if _attempts_exhausted(attempts):
             mark_failed(conn, queue_id, err)
         else:
             release_claim(conn, queue_id, err)
         return False
 
+    log.info(
+        f"completed queue_id={queue_id} event_id={event_id} producer={producer} "
+        f"entities={len(name_to_id)} facts={n_facts} relationships={n_rels}"
+        f" det_edges={len(det_rels)}"
+        + (f" llm_ms={llm_ms:.0f}" if not stub_mode and llm_ms else "")
+    )
+    # Best-effort side-writes, AFTER the graph commit and OUTSIDE the transaction:
+    # a failure here must not roll back the committed graph rows, and an error
+    # inside the txn would poison it (a swallowed error leaves the txn aborted).
+    # Trace: ONLY the teacher produces training gold; logging student output would
+    # train the student on itself.
+    if DISTILL_TRACE_ENABLED and not stub_mode and producer == "teacher":
+        try:
+            _insert_trace(
+                conn,
+                event_id=event_id,
+                user_prompt=build_event_block(local_idx, event),
+                raw_response=result.get("raw_slice", ""),
+                llm_chunk_ms=llm_ms,
+            )
+        except Exception as trace_exc:
+            log.warning(
+                f"trace insert failed queue_id={queue_id} "
+                f"event_id={event_id}: {trace_exc}"
+            )
+    # Cascade ledger — best-effort, records which producer wrote this
+    # event's rows (only when the cascade is on).
+    if CASCADE_ENABLED:
+        try:
+            _record_distillation(
+                conn,
+                event_id=event_id,
+                producer=producer,
+                llm_model=LLM_MODEL if producer == "teacher" else STUDENT_MODEL,
+                escalated=escalated,
+                escalate_reason=escalate_reason,
+            )
+        except Exception as ledger_exc:
+            log.warning(
+                f"ledger insert failed queue_id={queue_id} "
+                f"event_id={event_id}: {ledger_exc}"
+            )
+    return True
+
 
 async def amain():
     log.info(