topos-node 1.3.48__tar.gz → 1.3.50__tar.gz

{topos_node-1.3.48/topos_node.egg-info → topos_node-1.3.50}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topos-node
-Version: 1.3.48
+Version: 1.3.50
 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.48 → topos_node-1.3.50}/pyproject.toml

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

{topos_node-1.3.48 → topos_node-1.3.50}/topos/__version__.py

@@ -1,6 +1,6 @@
 """Topos Control Plane Version Information."""
 
-__version__ = "1.3.48"
-__version_info__ = (1, 3, 48)
+__version__ = "1.3.50"
+__version_info__ = (1, 3, 50)
 
 __all__ = ["__version__", "__version_info__"]

{topos_node-1.3.48 → topos_node-1.3.50}/topos/engine/backends/ollama.py

@@ -455,13 +455,23 @@ class OllamaAdapter:
                 prompt_tokens = int(data.get("prompt_eval_count") or 0)
                 completion_tokens = int(data.get("eval_count") or 0)
                 total_tokens = prompt_tokens + completion_tokens
+                # This is the DERIVATION lane, and it had no timing signal at
+                # all — no streaming, no heartbeats, no usage rows. It also
+                # alternates models with chat, which evicts weights and pays a
+                # cold load the chat lane then blames on itself. Capture the
+                # same split here so the two lanes are comparable.
+                from topos.services.llm.openai import _ollama_timings
+
+                timings = _ollama_timings(data)
                 return {
                     "text": data.get("response", ""),
                     "usage": {
                         "prompt_tokens": max(0, prompt_tokens),
                         "completion_tokens": max(0, completion_tokens),
                         "total_tokens": max(0, total_tokens),
+                        **({"timings": timings} if timings else {}),
                     },
+                    **({"timings": timings} if timings else {}),
                 }
         except urllib.error.HTTPError as e:
             # Include the response body: Ollama puts the actionable message

{topos_node-1.3.48 → topos_node-1.3.50}/topos/engine/engine.py

@@ -273,7 +273,12 @@ class Engine:
                     origin=origin,
                     source_id=normalized.source_id,
                     duration_ms=duration_ms,
-                    ttfb_ms=duration_ms,
+                    # Engine.run is NON-STREAMING: the whole body arrives at
+                    # once, so there is no first-token moment to measure here.
+                    # Passing duration as ttfb manufactured the sentinel that
+                    # poisoned the column — leave it unset and let the absence
+                    # be visible.
+                    ttfb_ms=None,
                 )
             except Exception:
                 logger.debug("Failed to emit engine llm usage observation", exc_info=True)

{topos_node-1.3.48 → topos_node-1.3.50}/topos/engine/usage_observation.py

@@ -370,9 +370,16 @@ def emit_engine_llm_usage_observation(
         "provider": provider_key,
         "model": model_key,
     }
-    # Non-streaming Engine.run: first token/body arrives with the completed response.
+    # ttfb_ms is RECORDED OR ABSENT — never inferred from duration.
+    #
+    # It used to default to `resolved_duration`, and the result was that 120 of
+    # 135 home-chat rows carried ttfb_ms == duration_ms. Every percentile anyone
+    # computed from that column was a duration percentile wearing a TTFB label,
+    # and the one metric this system is now being tuned for was, in effect, not
+    # measured at all. An honest NULL is a gap you can see; a plausible wrong
+    # number is one you cannot.
     resolved_duration = int(duration_ms) if duration_ms is not None else None
-    resolved_ttfb = int(ttfb_ms) if ttfb_ms is not None else resolved_duration
+    resolved_ttfb = int(ttfb_ms) if ttfb_ms is not None else None
     metadata: Dict[str, Any] = {
         "purpose": purpose,
         "provider": provider_key,

{topos_node-1.3.48 → topos_node-1.3.50}/topos/features/derivation/surfaces.py

@@ -232,6 +232,27 @@ def run_pack_backfill(conn: sqlite3.Connection, pack_id: str, limit: int = 500)
         conn.commit()
     conn.commit()
     stats["quarantined"] = writer.stats.get("quarantined", 0) - stats.pop("quarantined0")
+
+    # A backfill IS a run. Without this the registry keeps last_run_at NULL and
+    # the lens card reads "never run" over a pack that just wrote facts —
+    # observed 2026-09-03 on values.motivation, 73 records in, 11 facts out,
+    # card still blank. mark_pack_run is otherwise only called at the end of an
+    # ingest batch (derivation_job.py:292), which a quiet node may never have.
+    from .registry import mark_pack_run
+    mark_pack_run(conn, pack_id, pack.version)
+
+    # Embed what we just wrote, or the owner can see these facts on the Facts
+    # page and cannot ask about them: the semantic lane reads signal_embeddings,
+    # and the embedding job runs only when an ingest batch happens. Idempotent
+    # and incremental by content hash, so this is cheap when there is nothing
+    # new. Never fatal — the facts are already committed, and a missing
+    # embedding is a degraded answer, not a lost fact.
+    try:
+        from ...features.signal.derived_index import index_derived_objects
+        stats["indexed"] = int(index_derived_objects(conn).get("embedded", 0) or 0)
+    except Exception:  # noqa: BLE001 — see comment above: never fatal
+        stats["indexed"] = -1
+    conn.commit()
     return stats
 
 

{topos_node-1.3.48 → topos_node-1.3.50}/topos/ingestion/ingest_helpers.py

@@ -16,6 +16,40 @@ from ..storage.raw.file_store import RawFileStore
 logger = logging.getLogger("topos.ingestion.ingest_helpers")
 
 
+def chat_ui_raw_payload(payload: dict, *, job_id: str, dataset_id: str) -> dict:
+    """Map a chat UI-stream record to the v1 raw shape {id, thread_id, role, content, created_at}.
+
+    The v1 chat vocabulary — {id, thread_id, role} — is what the file importer,
+    the schema registry, and the browser extension all send. Older store_message
+    callers used {message_id, conversation_id, sender_type}. Read v1 first and
+    fall back to the legacy names, so a client on either vocabulary lands
+    correctly. Reading ONLY the legacy names (the prior behaviour) mislabelled
+    every extension message role=user (sender_type absent), merged every chat
+    under the dataset id (conversation_id absent), and minted a fresh id per
+    record (message_id absent), defeating message-id idempotency.
+    """
+    role = str(payload.get("role") or "").strip()
+    if not role:
+        sender_type = payload.get("sender_type", "human")
+        role = "user" if sender_type == "human" else str(sender_type)
+    created_at = payload.get("created_at")
+    if created_at is None:
+        ts = payload.get("ts")
+        if isinstance(ts, (int, float)):
+            created_at = ts
+        elif isinstance(ts, str):
+            created_at = ts
+        else:
+            created_at = datetime.now(timezone.utc).timestamp()
+    return {
+        "id": str(payload.get("id") or payload.get("message_id") or job_id),
+        "thread_id": payload.get("thread_id") or payload.get("conversation_id") or dataset_id,
+        "role": role,
+        "content": payload.get("content", ""),
+        "created_at": created_at,
+    }
+
+
 def _ui_stream_passes_payload_through(source: Any, source_id: str) -> bool:
     """True when ui_stream ingest should forward the client payload to the source parser."""
     if source_id.startswith("browser_"):
@@ -207,25 +241,7 @@ async def ingest_ui_payload(
     # Legacy path: ChatGPT UI only (backward compatibility when source_id omitted or chatgpt default)
     file_store = RawFileStore()
     job_id = job_id or str(uuid.uuid4())
-    sender_type = payload.get("sender_type", "human")
-    role = "user" if sender_type == "human" else sender_type
-    content = payload.get("content", "")
-    created_at = payload.get("created_at")
-    if created_at is None:
-        ts = payload.get("ts")
-        if isinstance(ts, (int, float)):
-            created_at = ts
-        elif isinstance(ts, str):
-            created_at = ts
-        else:
-            created_at = datetime.now(timezone.utc).timestamp()
-    record = {
-        "id": payload.get("message_id") or job_id,
-        "thread_id": payload.get("conversation_id") or dataset_id,
-        "role": role,
-        "content": content,
-        "created_at": created_at,
-    }
+    record = chat_ui_raw_payload(payload, job_id=job_id, dataset_id=dataset_id)
     logger.info(
         "[PIPELINE:RAW] Appending UI message to raw store: job_id=%s, dataset_id=%s, message_id=%s, content_preview=%s",
         job_id,
@@ -382,25 +398,7 @@ async def _ingest_ui_payload_direct(
             )
         raw_payload.setdefault("record_id", record_id)
     else:
-        sender_type = payload.get("sender_type", "human")
-        role = "user" if sender_type == "human" else sender_type
-        content = payload.get("content", "")
-        created_at = payload.get("created_at")
-        if created_at is None:
-            ts = payload.get("ts")
-            if isinstance(ts, (int, float)):
-                created_at = ts
-            elif isinstance(ts, str):
-                created_at = ts
-            else:
-                created_at = datetime.now(timezone.utc).timestamp()
-        raw_payload = {
-            "id": payload.get("message_id") or job_id,
-            "thread_id": payload.get("conversation_id") or dataset_id,
-            "role": role,
-            "content": content,
-            "created_at": created_at,
-        }
+        raw_payload = chat_ui_raw_payload(payload, job_id=job_id, dataset_id=dataset_id)
         record_id = raw_payload["id"]
     raw_record = RawRecord(record_id=record_id, payload=raw_payload)
 

{topos_node-1.3.48 → topos_node-1.3.50}/topos/protocol/narrowing_vocabulary.json

@@ -96,6 +96,7 @@
     "gate_vetoed",
     "grantee_scrub_facts",
     "hosted_binding_text_withheld",
+    "owner_permission_claim_replaced",
     "grantee_scrub_scores",
     "grantee_scrub_semantic_hits",
     "grantee_scrub_summaries",

{topos_node-1.3.48 → topos_node-1.3.50}/topos/query/narrowing.py

@@ -256,6 +256,7 @@ REASONS = frozenset(
         # --- engine: the grantee content filter, one per scrubbed artifact list
         "grantee_scrub_facts",
         "hosted_binding_text_withheld",
+        "owner_permission_claim_replaced",
         "grantee_scrub_scores",
         "grantee_scrub_semantic_hits",
         "grantee_scrub_summaries",

{topos_node-1.3.48 → topos_node-1.3.50}/topos/services/llm/openai.py

@@ -181,7 +181,90 @@ async def _ollama_generate(payload: Dict[str, Any]) -> Dict[str, Any]:
             "completion_tokens": completion_tokens,
             "total_tokens": total_tokens,
         }
-    return {"output": text, "model": resp_model, "usage": usage}
+    timings = _ollama_timings(data)
+    if timings:
+        usage = {**usage, "timings": timings}
+    return {"output": text, "model": resp_model, "usage": usage, "timings": timings}
+
+
+#: Nanoseconds-to-milliseconds, rounded to whole ms — the resolution anyone
+#: reasons about latency in. Ollama reports every duration in ns.
+def _ms(value: Any) -> int:
+    try:
+        return int(round(float(value) / 1e6))
+    except (TypeError, ValueError):
+        return 0
+
+
+#: Below this, the computed prefill rate is dominated by fixed overhead and
+#: says nothing about caching. Live false positive at 32 tokens.
+_CACHE_SIGNAL_MIN_PROMPT_TOKENS = 512
+
+#: Sits in the empty band between the fastest observed REAL prefill (~1,045
+#: tok/s on a 3B) and the slowest observed cache HIT (~17,565 tok/s on a 27B).
+_CACHE_HIT_TOK_S = 3000.0
+
+
+def _ollama_timings(data: Dict[str, Any]) -> Dict[str, Any]:
+    """Split a generation into load, prefill and decode.
+
+    Ollama puts ``total_duration``, ``load_duration``, ``prompt_eval_duration``
+    and ``eval_duration`` on the SAME terminating JSON object we already read
+    token counts from, and every one of them was being thrown away — at four
+    parse sites, for the whole life of this codebase. A repo-wide search for
+    ``load_duration`` found two hits, both prose in a plan document: it was
+    specified and never built.
+
+    Without the split, "the model was slow" is unanswerable. With it the three
+    causes separate cleanly. Measured on this machine 2026-09-03:
+
+    * ``load`` — weights into memory. Cold 5,695 ms on a 27B, warm 4.7 ms. The
+      544x separation is why ``cold`` below is a threshold and not a guess.
+    * ``prefill`` — reading the prompt. THE one that matters: it IS
+      time-to-first-token, ~65-90 tok/s, and 78 s of a real turn.
+    * ``decode`` — writing the answer, 3.4-10.1 tok/s. Caching cannot touch it.
+
+    ``prefill_cached`` is a prefix-cache hit, and it is deliberately NOT
+    ``prompt_eval_duration == 0``: measured hits ran 74-191 ms on a 3B and
+    ~6,300 ms on a 27B, and ``prompt_eval_count`` still reports the FULL prompt
+    on a hit, so the duration is the only signal there is.
+    """
+    load_ms = _ms(data.get("load_duration"))
+    prefill_ms = _ms(data.get("prompt_eval_duration"))
+    decode_ms = _ms(data.get("eval_duration"))
+    prompt_toks = int(data.get("prompt_eval_count") or 0)
+    completion_toks = int(data.get("eval_count") or 0)
+    timings: Dict[str, Any] = {
+        "load_ms": load_ms,
+        "prefill_ms": prefill_ms,
+        "decode_ms": decode_ms,
+        "total_ms": _ms(data.get("total_duration")),
+        # A cold load is 3 orders of magnitude from a warm one; 1s sits in the
+        # empty middle of that gap rather than near either edge.
+        "cold": load_ms >= 1000,
+    }
+    if prompt_toks and prefill_ms > 0:
+        timings["prefill_tok_s"] = round(prompt_toks * 1000.0 / prefill_ms, 1)
+    if completion_toks and decode_ms > 0:
+        timings["decode_tok_s"] = round(completion_toks * 1000.0 / decode_ms, 1)
+    # A hit still reports the full prompt_eval_count, so it has to be inferred
+    # from the RATE. Two guards, both learned from a false positive in live
+    # data: a 32-token prompt to a 3B model reported 561 tok/s and was flagged
+    # as cached when nothing was cached at all.
+    #
+    # 1. Short prompts carry no signal. Below a few hundred tokens the fixed
+    #    per-request overhead dominates and the computed rate is noise.
+    # 2. The threshold has to clear a SMALL model's genuine speed, not just a
+    #    large one's. Measured real prefill: 65-90 tok/s on a 27B, but
+    #    684-1,045 tok/s on a 3B. Measured cache hits: 17,565 tok/s (27B) and
+    #    33,275 tok/s (3B). 3,000 sits in the empty band between the fastest
+    #    real prefill and the slowest hit, rather than just above the one
+    #    model it was first calibrated on.
+    rate = timings.get("prefill_tok_s")
+    if prompt_toks >= _CACHE_SIGNAL_MIN_PROMPT_TOKENS and isinstance(rate, float):
+        if rate > _CACHE_HIT_TOK_S:
+            timings["prefill_cached"] = True
+    return timings
 
 
 async def _ollama_stream_generate(
@@ -245,6 +328,9 @@ async def _ollama_stream_generate(
     prompt_tokens = 0
     completion_tokens = 0
     done_reason = ""
+    # Stays empty when the stream ends without a terminating frame — a dropped
+    # connection must not raise a NameError on the way out.
+    timings: Dict[str, Any] = {}
     # Liveness (plan §2): phase-aware heartbeats whenever nothing else flows —
     # 10s pre-first-token (load + prefill are silent), 30s mid-stream. Emitted
     # frames of any kind reset the clock.
@@ -306,6 +392,7 @@ async def _ollama_stream_generate(
                         prompt_tokens = int(data.get("prompt_eval_count") or prompt_tokens)
                         completion_tokens = int(data.get("eval_count") or completion_tokens)
                         done_reason = str(data.get("done_reason") or "")
+                        timings = _ollama_timings(data)
     except httpx.RequestError as exc:
         raise HTTPException(
             status_code=status.HTTP_502_BAD_GATEWAY,
@@ -335,6 +422,13 @@ async def _ollama_stream_generate(
             "total_tokens": total_tokens,
         }
     result: Dict[str, Any] = {"output": text, "model": resp_model, "usage": usage}
+    # Nested under usage on purpose: the browser whitelists exactly
+    # output/model/usage (homeLlmStream.ts:415), and the control plane passes
+    # the payload through verbatim (_final_payload, llm_generation_sse.py:353),
+    # so timings reach the UI with NO control-plane change.
+    if timings:
+        result["usage"] = {**usage, "timings": timings}
+        result["timings"] = timings
     if thinking_chars:
         result["thinking_chars"] = thinking_chars
     if done_reason:

{topos_node-1.3.48 → topos_node-1.3.50}/topos/upgrades/manifests.json

@@ -813,6 +813,18 @@
       "steps": [],
       "notes": []
     },
+    {
+      "version": "1.3.49",
+      "summary": "Release 1.3.49.",
+      "steps": [],
+      "notes": []
+    },
+    {
+      "version": "1.3.50",
+      "summary": "Release 1.3.50.",
+      "steps": [],
+      "notes": []
+    },
     {
       "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.48 → topos_node-1.3.50/topos_node.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topos-node
-Version: 1.3.48
+Version: 1.3.50
 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