topos-node 1.3.34__tar.gz → 1.3.35__tar.gz

{topos_node-1.3.34/topos_node.egg-info → topos_node-1.3.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topos-node
-Version: 1.3.34
+Version: 1.3.35
 Summary: Topos personal AI engine (FastAPI): local data, sync, control plane WebSocket client
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://topos.dialogues.ai

{topos_node-1.3.34 → topos_node-1.3.35}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "topos-node"
-version = "1.3.34"
+version = "1.3.35"
 description = "Topos personal AI engine (FastAPI): local data, sync, control plane WebSocket client"
 readme = "README.md"
 license = "Apache-2.0"

{topos_node-1.3.34 → topos_node-1.3.35}/topos/__version__.py

@@ -1,6 +1,6 @@
 """Topos Control Plane Version Information."""
 
-__version__ = "1.3.34"
-__version_info__ = (1, 3, 34)
+__version__ = "1.3.35"
+__version_info__ = (1, 3, 35)
 
 __all__ = ["__version__", "__version_info__"]

{topos_node-1.3.34 → topos_node-1.3.35}/topos/upgrades/manifests.json

@@ -652,6 +652,34 @@
         "Migration 72 (derived_row_identity_v1) runs before the step above and is what makes it safe. It collapses derived rows duplicated by re-derivation and re-keys the survivors onto their identity. On a copy of a live node it took message_entities from 50,049 rows to 8,572 -- exactly the count of distinct typed identities, verified independently in SQL -- with user_goals 4,192->1,942, message_topics 2,594->762 and message_sentiment 1,792->105. Rows whose required identity fields are missing are left untouched rather than merged."
       ]
     },
+    {
+      "version": "1.3.35",
+      "summary": "Release 1.3.35.",
+      "steps": [
+        {
+          "id": "reextract-entities-structured-fields-retry",
+          "kind": "enrichment_reprocess",
+          "title": "Re-run the entities re-extraction that 1.3.34 recorded as done without doing",
+          "why": "1.3.34 declared reextract-entities-structured-fields as consent: prompt. On any node that approved it through the UI it did nothing: both consent entry points are async, the executor called asyncio.run inside the running loop, every source raised, and the runner ledgered the step done anyway -- which advanced the baseline, so it is never retried. A node that approved it has a ledger row saying done and none of the work. This step is the retry, under a new id because the old row is unreachable. Nodes that never approved it are unaffected: their 1.3.34 row is still pending_consent and this one supersedes it.",
+          "params": {
+            "job_names": [
+              "entities"
+            ],
+            "force_reprocess": false,
+            "include_signal": false,
+            "per_source": true
+          },
+          "progress": "TUI progress bar on the node + GET /v1/upgrade/status",
+          "idempotent": "Yes: message_entities rows are keyed on (record_id, entity_text, entity_type) since migration 72, so a re-run REPLACES rather than appends. Running it twice is a no-op on row count.",
+          "estimated_duration": "~10-20 min per 1.5k records (CPU-bound local NER, no API cost); node stays usable and serves the existing graph meanwhile",
+          "consent": "prompt",
+          "order": 1
+        }
+      ],
+      "notes": [
+        "The runner fix ships in the same release: _run_coro runs the coroutine on its own loop in a worker thread when one already owns the caller's, and a step whose sources ALL errored now fails instead of being ledgered done. Without both, approving the step above would fail the same silent way."
+      ]
+    },
     {
       "version": "unreleased",
       "summary": "Staging entry for in-flight PRs. cut_release.py stamps this with the next version at release cut. Never executed by steps_between.",

{topos_node-1.3.34 → topos_node-1.3.35}/topos/upgrades/runner.py

@@ -26,6 +26,7 @@ engine internals (no HTTP self-calls).
 
 from __future__ import annotations
 
+import asyncio
 import json
 import logging
 import os
@@ -321,6 +322,73 @@ def ledger_rows(conn: sqlite3.Connection) -> List[Dict[str, Any]]:
 # --- real executors ----------------------------------------------------------
 
 
+def _fail_if_every_source_errored(step_id: str, outcomes: Dict[str, Any]) -> None:
+    """Raise when a per-source step failed on ALL of them.
+
+    The runner ledgers ``done`` whenever an executor returns without raising, so
+    an executor that catches per-source exceptions and records them as strings
+    reports success no matter how badly it went -- and ``done`` advances the
+    baseline, so the step is never retried and nothing surfaces.
+
+    That is exactly how the 1.3.34 entities reprocess reported success: 11 of 11
+    sources returned ``asyncio.run() cannot be called from a running event
+    loop`` in 6 ms, and the ledger said done. A partial failure is still ``done``
+    (one dead source must not block an upgrade), but a total one is a failed
+    step -- which is retried, and which the status endpoint shows.
+    """
+    if not outcomes:
+        return
+    errored = [s for s, v in outcomes.items() if str(v).startswith("error:")]
+    if len(errored) != len(outcomes):
+        return
+    sample = str(outcomes[errored[0]])[:200]
+    raise RuntimeError(
+        f"{step_id}: every source failed ({len(errored)}/{len(outcomes)}) - {sample}"
+    )
+
+
+def _run_coro(coro: Any) -> Any:
+    """Run ``coro`` to completion whether or not an event loop already owns this thread.
+
+    The upgrade runner has two kinds of caller and only one of them was ever
+    exercised. Boot runs it on a worker thread (``topos-upgrade-stamp``), where
+    ``asyncio.run`` is fine. But BOTH consent entry points -- ``POST
+    /v1/upgrade/consent`` and the ``consent_upgrade_step`` websocket handler --
+    are ``async def``, so they call this from inside the running loop, where
+    ``asyncio.run`` raises ``RuntimeError: asyncio.run() cannot be called from a
+    running event loop``.
+
+    Measured on a live node 2026-08-28, approving the 1.3.34 entities reprocess:
+    all 11 sources returned that error in 6 ms and the step was still ledgered
+    ``done``. Every consent:prompt reprocess ever approved through the UI has
+    been a silent no-op -- the steps that ask permission are exactly the
+    expensive ones nobody wants to run twice, so nobody re-ran them.
+
+    When a loop is already running we cannot block on it, so the coroutine gets
+    its own loop on a worker thread and we join. The runner is already off the
+    request path conceptually; this makes it so in fact.
+    """
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(coro)
+
+    result: Dict[str, Any] = {}
+
+    def _worker() -> None:
+        try:
+            result["value"] = asyncio.run(coro)
+        except BaseException as exc:  # noqa: BLE001 — re-raised on the caller's thread
+            result["error"] = exc
+
+    thread = threading.Thread(target=_worker, name="topos-upgrade-coro", daemon=True)
+    thread.start()
+    thread.join()
+    if "error" in result:
+        raise result["error"]
+    return result.get("value")
+
+
 def _real_source_ids(conn: sqlite3.Connection) -> List[str]:
     skip = ("demo_", "enrichment_lab", "sanity", "test", "manual_enrichment")
     try:
@@ -404,7 +472,7 @@ def _exec_enrichment_reprocess(step: Dict[str, Any], conn: sqlite3.Connection) -
             if pbar is not None:
                 pbar.set_description(f"Upgrade {step_id} · {source_id}")
             try:
-                out = asyncio.run(
+                out = _run_coro(
                     _process_enrichment_core(
                         source_id=source_id,
                         job_names=(canonical_jobs if declared else None),
@@ -442,6 +510,7 @@ def _exec_enrichment_reprocess(step: Dict[str, Any], conn: sqlite3.Connection) -
             total=len(source_ids),
         )
     )
+    _fail_if_every_source_errored(step_id, detail["sources"])
     return detail
 
 
@@ -465,7 +534,7 @@ def _exec_engine_endpoint(step: Dict[str, Any], conn: sqlite3.Connection) -> Dic
 
         params = step.get("params") or {}
         return dict(
-            asyncio.run(
+            _run_coro(
                 retry_pending_derivations(
                     conn,
                     source_id=params.get("source_id"),
@@ -512,7 +581,7 @@ def _exec_canonical_reprocess(step: Dict[str, Any], conn: sqlite3.Connection) ->
     }
     for source_id in source_ids:
         try:
-            out = asyncio.run(
+            out = _run_coro(
                 reprocess_source(
                     source_id=str(source_id),
                     dataset_id=str(params.get("dataset_id") or "default"),
@@ -524,6 +593,9 @@ def _exec_canonical_reprocess(step: Dict[str, Any], conn: sqlite3.Connection) ->
             detail["sources"][source_id] = str(out.get("status") or "ok")
         except Exception as exc:  # noqa: BLE001
             detail["sources"][source_id] = f"error: {exc}"
+    _fail_if_every_source_errored(
+        str(step.get("id") or "canonical_reprocess"), detail["sources"]
+    )
     return detail
 
 

{topos_node-1.3.34 → topos_node-1.3.35/topos_node.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topos-node
-Version: 1.3.34
+Version: 1.3.35
 Summary: Topos personal AI engine (FastAPI): local data, sync, control plane WebSocket client
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://topos.dialogues.ai