topos-node 1.2.3__tar.gz → 1.2.5__tar.gz

{topos_node-1.2.3/topos_node.egg-info → topos_node-1.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topos-node
-Version: 1.2.3
+Version: 1.2.5
 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
@@ -213,6 +213,76 @@ pip install -e ".[dev,engine]"
 pytest tests -m "public and not e2e" -q
 ```
 
+## Plugins
+
+Topos Node supports **optional plugins**: separate Python packages installed alongside
+`topos-node` that register handlers, connectors, or other runtime hooks. The core node
+does not hardcode plugin names — discovery is entirely via setuptools entry points.
+
+### Contract: `topos.extensions`
+
+| Rule | Detail |
+| --- | --- |
+| **Entry-point group** | `topos.extensions` |
+| **Entry-point target** | A callable, e.g. `my_plugin:register` |
+| **When it runs** | At process startup, before the server accepts traffic (`topos/extensions.py`) |
+| **Failure mode** | A broken plugin is logged and skipped; the node keeps running |
+| **Dependencies** | Your plugin declares `topos-node` (or `topos-node[local]`) in its own `pyproject.toml` |
+
+**Minimal plugin**
+
+`pyproject.toml`:
+
+```toml
+[project]
+name = "my-topos-plugin"
+dependencies = ["topos-node[local]"]
+
+[project.entry-points."topos.extensions"]
+my_plugin = "my_topos_plugin:register"
+```
+
+`my_topos_plugin/__init__.py`:
+
+```python
+def register() -> None:
+    from my_topos_plugin.handlers import example  # noqa: F401 — registers @handles
+```
+
+`my_topos_plugin/handlers/example.py`:
+
+```python
+from typing import Any, Dict, Optional
+from topos.core.handlers.registry import handles
+
+@handles("my_message_type")
+async def handle_my_message(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    return {"status": "ok", "payload": {"received": message.get("type")}}
+```
+
+**Install and run**
+
+```bash
+pip install topos-node my-topos-plugin
+topos-node
+```
+
+Handlers registered in `register()` are available to the control-plane WebSocket
+and local API paths that dispatch through `topos.core.handlers`.
+
+### Starter template
+
+Fork **[dialoguesai/topos-plugin-template](https://github.com/dialoguesai/topos-plugin-template)**
+for a working package with tests and CI. It registers a sample `plugin_template_ping`
+handler you can copy and rename.
+
+### Guidelines
+
+- Use **unique message type names** (prefix with your project) to avoid colliding with core handlers.
+- Keep plugins in **separate repositories** — do not add proprietary logic to this repo.
+- Message types your plugin handles do not need to appear in the public engine protocol
+  snapshot unless the hosted control plane will send them to all nodes.
+
 ## Contributing
 
 See `CONTRIBUTING.md` for:

{topos_node-1.2.3 → topos_node-1.2.5}/README.md

@@ -156,6 +156,76 @@ pip install -e ".[dev,engine]"
 pytest tests -m "public and not e2e" -q
 ```
 
+## Plugins
+
+Topos Node supports **optional plugins**: separate Python packages installed alongside
+`topos-node` that register handlers, connectors, or other runtime hooks. The core node
+does not hardcode plugin names — discovery is entirely via setuptools entry points.
+
+### Contract: `topos.extensions`
+
+| Rule | Detail |
+| --- | --- |
+| **Entry-point group** | `topos.extensions` |
+| **Entry-point target** | A callable, e.g. `my_plugin:register` |
+| **When it runs** | At process startup, before the server accepts traffic (`topos/extensions.py`) |
+| **Failure mode** | A broken plugin is logged and skipped; the node keeps running |
+| **Dependencies** | Your plugin declares `topos-node` (or `topos-node[local]`) in its own `pyproject.toml` |
+
+**Minimal plugin**
+
+`pyproject.toml`:
+
+```toml
+[project]
+name = "my-topos-plugin"
+dependencies = ["topos-node[local]"]
+
+[project.entry-points."topos.extensions"]
+my_plugin = "my_topos_plugin:register"
+```
+
+`my_topos_plugin/__init__.py`:
+
+```python
+def register() -> None:
+    from my_topos_plugin.handlers import example  # noqa: F401 — registers @handles
+```
+
+`my_topos_plugin/handlers/example.py`:
+
+```python
+from typing import Any, Dict, Optional
+from topos.core.handlers.registry import handles
+
+@handles("my_message_type")
+async def handle_my_message(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    return {"status": "ok", "payload": {"received": message.get("type")}}
+```
+
+**Install and run**
+
+```bash
+pip install topos-node my-topos-plugin
+topos-node
+```
+
+Handlers registered in `register()` are available to the control-plane WebSocket
+and local API paths that dispatch through `topos.core.handlers`.
+
+### Starter template
+
+Fork **[dialoguesai/topos-plugin-template](https://github.com/dialoguesai/topos-plugin-template)**
+for a working package with tests and CI. It registers a sample `plugin_template_ping`
+handler you can copy and rename.
+
+### Guidelines
+
+- Use **unique message type names** (prefix with your project) to avoid colliding with core handlers.
+- Keep plugins in **separate repositories** — do not add proprietary logic to this repo.
+- Message types your plugin handles do not need to appear in the public engine protocol
+  snapshot unless the hosted control plane will send them to all nodes.
+
 ## Contributing
 
 See `CONTRIBUTING.md` for:

{topos_node-1.2.3 → topos_node-1.2.5}/pyproject.toml

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

topos_node-1.2.5/tests/test_extensions.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import pytest
+
+from topos.core.handlers.registry import handles
+from topos.extensions import load_extensions
+
+
+@pytest.mark.public
+def test_load_extensions_does_not_raise_when_no_plugins_installed() -> None:
+    load_extensions()
+
+
+@pytest.mark.public
+def test_load_extensions_invokes_entry_point_callables(monkeypatch: pytest.MonkeyPatch) -> None:
+    seen: list[str] = []
+
+    def _init() -> None:
+        seen.append("ran")
+
+    class _FakeEntryPoint:
+        name = "test"
+
+        def load(self) -> object:
+            return _init
+
+    monkeypatch.setattr(
+        "topos.extensions._iter_extension_entry_points",
+        lambda: [_FakeEntryPoint()],
+    )
+    load_extensions()
+    assert seen == ["ran"]

{topos_node-1.2.3 → topos_node-1.2.5}/topos/__version__.py

@@ -1,6 +1,6 @@
 """Topos Control Plane Version Information."""
 
-__version__ = "1.2.3"
-__version_info__ = (1, 2, 3)
+__version__ = "1.2.5"
+__version_info__ = (1, 2, 5)
 
 __all__ = ["__version__", "__version_info__"]

{topos_node-1.2.3 → topos_node-1.2.5}/topos/api/enrichment.py

@@ -319,7 +319,14 @@ def _enrichment_coverage_core(source_id: str) -> Dict[str, Any]:
             "output_rows": {},
         }
         coverage_table = coverage_table_for_job(job_id)
-        if coverage_table and _table_exists(conn, coverage_table):
+        if job_id == "timeline":
+            from ..features.timeline_projection import timeline_coverage_for_source
+
+            timeline_stats = timeline_coverage_for_source(conn, source_id)
+            job_info["enriched_records"] = timeline_stats["enriched_records"]
+            job_info["coverage_percent"] = timeline_stats["coverage_percent"]
+            job_info["output_rows"]["timeline"] = timeline_stats["enriched_records"]
+        elif coverage_table and _table_exists(conn, coverage_table):
             cols = _table_columns(conn, coverage_table)
             id_col = "message_id" if "message_id" in cols else "record_id"
             if "source_id" in cols and id_col in cols:
@@ -552,24 +559,50 @@ async def _generic_backfill_core(
     scanned = len(records)
 
     if only_missing:
-        coverage_table = coverage_table_for_job(job_name)
-        if coverage_table and _table_exists(db_conn, coverage_table):
-            cols = _table_columns(db_conn, coverage_table)
-            id_col = "message_id" if "message_id" in cols else "record_id"
-            if "source_id" in cols and id_col in cols:
-                done = {
-                    str(row[0])
-                    for row in db_conn.execute(
-                        f"SELECT DISTINCT {id_col} FROM {coverage_table} WHERE source_id=?",
-                        (source_id,),
-                    ).fetchall()
-                    if row[0]
+        if job_name == "timeline":
+            from ..features.timeline_projection import timeline_coverage_for_source
+
+            stats = timeline_coverage_for_source(db_conn, source_id)
+            if stats["missing_records"] == 0:
+                return {
+                    "rows_scanned": scanned,
+                    "rows_processed": 0,
+                    "rows_skipped": scanned,
+                    "rows_failed": 0,
+                    "errors": [],
                 }
-                records = [r for r in records if _record_identifier(r) not in done]
+        else:
+            coverage_table = coverage_table_for_job(job_name)
+            if coverage_table and _table_exists(db_conn, coverage_table):
+                cols = _table_columns(db_conn, coverage_table)
+                id_col = "message_id" if "message_id" in cols else "record_id"
+                if "source_id" in cols and id_col in cols:
+                    done = {
+                        str(row[0])
+                        for row in db_conn.execute(
+                            f"SELECT DISTINCT {id_col} FROM {coverage_table} WHERE source_id=?",
+                            (source_id,),
+                        ).fetchall()
+                        if row[0]
+                    }
+                    records = [r for r in records if _record_identifier(r) not in done]
 
     if isinstance(limit, int) and limit > 0:
         records = records[:limit]
 
+    if job_name == "timeline":
+        from ..features.timeline_projection import repair_timeline_for_source
+
+        report = repair_timeline_for_source(db_conn, source_id, missing_only=True, dry_run=False)
+        processed = int(report.get("totals", {}).get("written", 0))
+        return {
+            "rows_scanned": scanned,
+            "rows_processed": processed,
+            "rows_skipped": max(scanned - processed, 0),
+            "rows_failed": 0,
+            "errors": [],
+        }
+
     if not records:
         return {
             "rows_scanned": scanned,
@@ -950,6 +983,7 @@ async def _process_enrichment_core(
     job_names: Optional[List[str]] = None,
     force_reprocess: bool = False,
     include_signal: bool = True,
+    progress_updater: Optional[Any] = None,
 ) -> Dict[str, Any]:
     """Core logic for processing enrichment (reusable from HTTP and WebSocket).
     
@@ -1024,32 +1058,64 @@ async def _process_enrichment_core(
     
     # Define progress callback to update progress during execution
     progress_callback = None
-    try:
-        from ..enrichment.progress import get_progress
-        # Try to get progress object if it exists (created by handler)
-        progress_obj = get_progress(source_id)  # Use source_id as fallback lookup
-        if progress_obj:
-            def progress_callback(
-                processed_count: int, 
-                total_count: int, 
-                job_name: str, 
-                job_percent: float,
-                current_job_progress: float,
-            ):
-                """Update progress as jobs execute."""
-                estimated_messages_processed = int((job_percent / 100) * total_count)
-                jobs_complete = int((job_percent / 100) * len(jobs_to_run))
-                progress_obj.update(
-                    messages_processed=estimated_messages_processed,
-                    messages_skipped=0,
-                    current_job_name=job_name,
-                    current_job_progress_percent=current_job_progress,
-                    jobs_complete=jobs_complete,
-                    jobs_total=len(jobs_to_run),
-                )
-    except Exception:
-        pass  # Progress callback is optional
+    if progress_updater is not None:
+        def progress_callback(
+            processed_count: int,
+            total_count: int,
+            job_name: str,
+            job_percent: float,
+            current_job_progress: float,
+        ):
+            estimated_messages_processed = int((job_percent / 100) * total_count) if total_count else 0
+            jobs_complete = int((job_percent / 100) * len(jobs_to_run)) if jobs_to_run else 0
+            progress_updater(
+                {
+                    "status": "processing",
+                    "progress_percent": min(100.0, job_percent),
+                    "messages_processed": estimated_messages_processed,
+                    "messages_skipped": 0,
+                    "messages_total": total_count,
+                    "current_job_name": job_name,
+                    "current_job_progress_percent": current_job_progress,
+                    "jobs_complete": jobs_complete,
+                    "jobs_total": len(jobs_to_run),
+                    "jobs_progress_percent": (jobs_complete / len(jobs_to_run) * 100) if jobs_to_run else 0.0,
+                }
+            )
+    else:
+        try:
+            from ..enrichment.progress import get_progress
+            progress_obj = get_progress(source_id)
+            if progress_obj:
+                def progress_callback(
+                    processed_count: int,
+                    total_count: int,
+                    job_name: str,
+                    job_percent: float,
+                    current_job_progress: float,
+                ):
+                    estimated_messages_processed = int((job_percent / 100) * total_count)
+                    jobs_complete = int((job_percent / 100) * len(jobs_to_run))
+                    progress_obj.update(
+                        messages_processed=estimated_messages_processed,
+                        messages_skipped=0,
+                        current_job_name=job_name,
+                        current_job_progress_percent=current_job_progress,
+                        jobs_complete=jobs_complete,
+                        jobs_total=len(jobs_to_run),
+                    )
+        except Exception:
+            pass
     
+    if progress_updater is not None:
+        progress_updater(
+            {
+                "status": "processing",
+                "messages_total": len(unprocessed_messages),
+                "jobs_total": len(jobs_to_run),
+            }
+        )
+
     enrichment_result = await orchestrator.run_canonical(
         unprocessed_messages,
         job_names=jobs_to_run,

{topos_node-1.2.3 → topos_node-1.2.5}/topos/api/llm.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import hashlib
+import logging
 
 from fastapi import APIRouter, Depends
 
@@ -10,6 +11,8 @@ from ..engine.usage_observation import emit_usage_observation
 from ..rate_limit import rate_limit
 from ..services.container import Services, get_services
 
+logger = logging.getLogger("topos.api.llm")
+
 router = APIRouter()
 
 
@@ -19,6 +22,12 @@ router = APIRouter()
     dependencies=[Depends(require_api_key), Depends(rate_limit)],
 )
 async def llm_generation(body: GenerationRequest):
+    logger.info(
+        "llm_generation request: provider=%r model=%r prompt_chars=%d",
+        body.provider,
+        body.model,
+        len(body.prompt or ""),
+    )
     services: Services = get_services()
     result = await services.llm.generate(body.model_dump())
     usage = result.get("usage") if isinstance(result, dict) else {}
@@ -45,6 +54,12 @@ async def llm_generation(body: GenerationRequest):
     dependencies=[Depends(require_api_key), Depends(rate_limit)],
 )
 async def llm_generation_alias(body: GenerationRequest):
+    logger.info(
+        "llm_generation request (alias): provider=%r model=%r prompt_chars=%d",
+        body.provider,
+        body.model,
+        len(body.prompt or ""),
+    )
     services: Services = get_services()
     result = await services.llm.generate(body.model_dump())
     usage = result.get("usage") if isinstance(result, dict) else {}

{topos_node-1.2.3 → topos_node-1.2.5}/topos/api/signal.py

@@ -232,11 +232,13 @@ async def list_entities(
 # as an entity id.
 @router.get("/entities/graph")
 async def get_entity_graph(
-    limit_nodes: int = Query(default=100, ge=1, le=500),
-    limit_edges: int = Query(default=300, ge=1, le=1500),
+    limit_nodes: int = Query(default=100, ge=1, le=5000),
+    limit_edges: int = Query(default=300, ge=1, le=20000),
     min_weight: float = Query(default=0.0, ge=0.0),
     include_closed: bool = Query(default=False),
     as_of: Optional[str] = Query(default=None),
+    selection: str = Query(default="weight"),
+    offset: int = Query(default=0, ge=0),
     _api_key: str = Depends(require_api_key),
 ):
     """Entity-spine graph (decayed typed edges) in list_graph node/edge shape.
@@ -244,16 +246,25 @@ async def get_entity_graph(
     Each edge carries valid_from/valid_to/last_event_at. ``as_of`` (ISO date)
     returns the graph as it stood at that instant (temporal scrubber);
     ``include_closed`` adds ended edges to the present view.
+
+    ``selection=weight`` (default) ranks by weight for MCP/minimal slices;
+    ``selection=all`` ranks by recency for the owner knowledge-graph UI.
     """
+    import asyncio
+
     from ..features.entities.reads import entity_graph
 
-    return entity_graph(
-        _entities_conn(),
+    conn = _entities_conn()
+    return await asyncio.to_thread(
+        entity_graph,
+        conn,
         limit_nodes=limit_nodes,
         limit_edges=limit_edges,
         min_weight=min_weight,
         include_closed=include_closed,
         as_of=as_of,
+        selection=selection,
+        offset=offset,
     )
 
 

{topos_node-1.2.3 → topos_node-1.2.5}/topos/api/source_install.py

@@ -11,6 +11,7 @@ from ..ingestion.ingest_helpers import ingest_file_payload, ingest_ui_payload
 from ..api.enrichment import _process_enrichment_core
 from ..engine.usage_observation import emit_usage_observation
 from ..sources import install_service
+from ..sources.definitions import with_source_capabilities
 
 router = APIRouter()
 logger = logging.getLogger("topos.api.source_install")
@@ -140,7 +141,7 @@ async def _list_sources_core(payload: Dict[str, Any]) -> Dict[str, Any]:
         source_def = rec.source_definition_json if isinstance(rec.source_definition_json, dict) else {}
         if not sid or sid in active_by_source or not source_def:
             continue
-        active_by_source[sid] = source_def
+        active_by_source[sid] = with_source_capabilities(source_def)
     sources = list(active_by_source.values())
     return {"status": "ok", "sources": sources}
 

topos_node-1.2.5/topos/api/tool_index.py

@@ -0,0 +1,86 @@
+"""Tool-RAG endpoints: sync the tool index, retrieve top-K tools for a query.
+
+PLAN_AGENT_QUALITY WS-3 (M2). The chat orchestration (topos-react-app) pushes
+the gateway's tool list here after ``tools/list`` (hash-deduped upsert → cheap
+no-op when unchanged) and calls ``/v1/tools/retrieve`` per turn to build a
+focused tool doc sized to the model instead of a flat 52-tool dump.
+
+Handlers are sync ``def`` on purpose: the embedding path is blocking HF
+inference, and FastAPI runs sync handlers in its threadpool.
+"""
+
+from __future__ import annotations
+
+from typing import List, Optional
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel, Field
+
+from ..auth import require_api_key
+from ..core.state import get_db_connection
+from ..features.signal.tool_index import index_status, index_tools, retrieve_tools
+from ..rate_limit import rate_limit
+
+router = APIRouter()
+
+
+class ToolSpecIn(BaseModel):
+    name: str
+    description: str = ""
+    connector_id: Optional[str] = None
+
+
+class IndexToolsRequest(BaseModel):
+    tools: List[ToolSpecIn] = Field(default_factory=list, max_length=2000)
+    # Prune index rows absent from this payload (full-list syncs only).
+    prune_missing: bool = False
+
+
+class RetrieveToolsRequest(BaseModel):
+    query: str
+    connector_scope: Optional[str] = None
+    k: int = 8
+
+
+def _require_conn():
+    conn = get_db_connection()
+    if conn is None:
+        raise HTTPException(status_code=503, detail="Database unavailable")
+    return conn
+
+
+@router.post(
+    "/v1/tools/index",
+    dependencies=[Depends(require_api_key), Depends(rate_limit)],
+)
+def tools_index(body: IndexToolsRequest):
+    conn = _require_conn()
+    specs = [spec.model_dump() for spec in body.tools if str(spec.name or "").strip()]
+    if not specs and not body.prune_missing:
+        raise HTTPException(status_code=422, detail="tools must be a non-empty list")
+    return index_tools(conn, specs, prune_missing=body.prune_missing)
+
+
+@router.post(
+    "/v1/tools/retrieve",
+    dependencies=[Depends(require_api_key), Depends(rate_limit)],
+)
+def tools_retrieve(body: RetrieveToolsRequest):
+    if not str(body.query or "").strip():
+        raise HTTPException(status_code=422, detail="query is required")
+    conn = _require_conn()
+    return retrieve_tools(
+        conn,
+        body.query,
+        connector_scope=body.connector_scope,
+        k=body.k,
+    )
+
+
+@router.get(
+    "/v1/tools/index/status",
+    dependencies=[Depends(require_api_key), Depends(rate_limit)],
+)
+def tools_index_status():
+    conn = _require_conn()
+    return index_status(conn)

{topos_node-1.2.3 → topos_node-1.2.5}/topos/app.py

@@ -45,10 +45,12 @@ from .api import (
     home_chat as home_chat_routes,
     privacy_disclose as privacy_disclose_routes,
     signal as signal_routes,
+    tool_index as tool_index_routes,
     upgrades as upgrades_routes,
 )
 from .config.settings import settings
 from .core.logging import align_uvicorn_loggers, configure_logging
+from .extensions import load_extensions
 from .core import state
 from .core.handlers import handle_control_plane_request
 from .control_plane_client import ControlPlaneClient
@@ -65,6 +67,7 @@ from .sync import SyncClient
 from .sync_handlers import handle_sync_op
 
 configure_logging()
+load_extensions()
 logger = logging.getLogger("topos.app")
 
 app = FastAPI(
@@ -128,10 +131,15 @@ app.include_router(privacy_disclose_routes.router)
 app.include_router(compute_remote_routes.router)
 app.include_router(engine_run_routes.router)
 app.include_router(data_commit_routes.router)
+app.include_router(tool_index_routes.router)
 
 
 @app.on_event("startup")
 async def startup_event() -> None:
+    from .runtime_shutdown import clear_shutdown, install_shutdown_signal_hooks
+
+    clear_shutdown()
+    install_shutdown_signal_hooks()
     align_uvicorn_loggers()
     _log_runtime_banner()
     logger.info("CORS allowed origins: %s", settings.allowed_origins)
@@ -172,6 +180,20 @@ async def startup_event() -> None:
             _start_upgrades(_upgrade_conn)
     except Exception as e:
         logger.warning("Upgrade runner at startup failed (non-fatal): %s", e)
+    try:
+        from .core.state import get_db_connection as _get_conn_for_pipeline
+        from .pipeline.job_runner import recover_pipeline_jobs, start_pipeline_worker
+        from .features.entities.graph_refresh import reconcile_graph_on_startup
+
+        _pipeline_conn = state.db_conn if state.db_conn is not None else _get_conn_for_pipeline()
+        if _pipeline_conn is not None:
+            recovered = recover_pipeline_jobs(_pipeline_conn)
+            if recovered:
+                logger.info("Recovered stale pipeline jobs on startup: count=%s", recovered)
+            reconcile_graph_on_startup(_pipeline_conn)
+            start_pipeline_worker(_get_conn_for_pipeline)
+    except Exception as e:
+        logger.warning("Pipeline worker at startup failed (non-fatal): %s", e)
     try:
         from .sources import install_service
 
@@ -185,6 +207,16 @@ async def startup_event() -> None:
             )
     except Exception as e:
         logger.warning("Active source install rehydration at startup failed (non-fatal): %s", e)
+    if getattr(settings, "sanitization_prewarm_on_startup", True):
+        async def _prewarm_sanitization() -> None:
+            try:
+                from .sanitization.prewarm import prewarm_sanitization_models
+
+                await asyncio.to_thread(prewarm_sanitization_models)
+            except Exception as prewarm_exc:  # noqa: BLE001
+                logger.warning("Sanitization prewarm at startup failed (non-fatal): %s", prewarm_exc)
+
+        asyncio.create_task(_prewarm_sanitization())
     if settings.topos_control_plane_url:
         if settings.hosted_pool_lease_enabled:
             try:
@@ -282,6 +314,11 @@ async def startup_event() -> None:
 
 @app.on_event("shutdown")
 async def shutdown_event() -> None:
+    from .runtime_shutdown import request_shutdown
+
+    # Wake cooperative workers (fact_llm / Ollama threads) before awaiting
+    # network teardown so Ctrl+C does not wait out a full enrichment batch.
+    request_shutdown("app_shutdown")
     await stop_runtime_update_monitor()
     if state.engine_presence_task:
         state.engine_presence_task.cancel()