synapse-cli-agent 0.1.13__py3-none-any.whl

synapse/models_registry.py

@@ -0,0 +1,7 @@
+"""Compatibility exports for the model domain.
+
+New code should import from :mod:`synapse.models.registry`.
+"""
+
+from synapse.models.registry import *  # noqa: F403
+from synapse.models.registry import _profiles_from_mapping as _profiles_from_mapping

synapse/observability/__init__.py

@@ -0,0 +1 @@
+"""Startup diagnostics and observability helpers."""

synapse/observability/startup_trace.py

@@ -0,0 +1,127 @@
+"""Optional startup timing tracer.
+
+Enable with env ``AGENT_STARTUP_TRACE=1`` (or ``true`` / ``yes``).
+Prints cumulative stage timings to stderr when the process finishes
+startup-critical work, or on demand via :func:`dump`.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import threading
+import time
+from collections.abc import Iterator
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from typing import Any
+
+
+def _env_enabled() -> bool:
+    raw = (os.environ.get("AGENT_STARTUP_TRACE") or "").strip().casefold()
+    return raw in {"1", "true", "yes", "on"}
+
+
+@dataclass
+class StartupTrace:
+    enabled: bool = field(default_factory=_env_enabled)
+    t0: float = field(default_factory=time.perf_counter)
+    # each mark: (name, ms_since_start, ms_step)
+    marks: list[tuple[str, float, float]] = field(default_factory=list)
+    _last: float = field(default_factory=time.perf_counter)
+
+    def reset(self) -> None:
+        self.t0 = time.perf_counter()
+        self._last = self.t0
+        self.marks.clear()
+
+    def mark(self, name: str) -> None:
+        if not self.enabled:
+            return
+        now = time.perf_counter()
+        since = (now - self.t0) * 1000
+        step = (now - self._last) * 1000
+        self._last = now
+        self.marks.append((name, since, step))
+
+    @contextmanager
+    def span(self, name: str) -> Iterator[None]:
+        if not self.enabled:
+            yield
+            return
+        t0 = time.perf_counter()
+        try:
+            yield
+        finally:
+            now = time.perf_counter()
+            since = (now - self.t0) * 1000
+            step = (now - t0) * 1000
+            self._last = now
+            self.marks.append((name, since, step))
+
+    def dump(self, *, header: str = "startup-trace", file=None) -> None:
+        if not self.enabled or not self.marks:
+            return
+        out = file or sys.stderr
+        total = (time.perf_counter() - self.t0) * 1000
+        print(f"[{header}] total={total:.1f}ms stages={len(self.marks)}", file=out)
+        for name, since, step in self.marks:
+            print(f"  +{step:8.1f}ms  @{since:8.1f}ms  {name}", file=out)
+        # Top offenders by step cost
+        top = sorted(self.marks, key=lambda x: x[2], reverse=True)[:8]
+        print(f"[{header}] top stages:", file=out)
+        for name, _since, step in top:
+            print(f"  {step:8.1f}ms  {name}", file=out)
+
+
+TRACE = StartupTrace()
+_LOCAL = threading.local()
+
+
+def _current_trace() -> StartupTrace:
+    if threading.current_thread() is threading.main_thread():
+        return TRACE
+    trace = getattr(_LOCAL, "trace", None)
+    if trace is None:
+        trace = StartupTrace()
+        _LOCAL.trace = trace
+    return trace
+
+
+def reset() -> None:
+    _current_trace().reset()
+
+
+def mark(name: str) -> None:
+    _current_trace().mark(name)
+
+
+def span(name: str):
+    return _current_trace().span(name)
+
+
+def dump(**kwargs) -> None:
+    _current_trace().dump(**kwargs)
+
+
+def duration(name: str, started: float, *, file=None, **fields: Any) -> None:
+    """Emit one independent duration line without mutating cumulative stage state."""
+    if not _current_trace().enabled:
+        return
+    elapsed = (time.perf_counter() - started) * 1000
+    suffix = " ".join(f"{key}={value}" for key, value in fields.items())
+    detail = f" {suffix}" if suffix else ""
+    out = file or sys.stderr
+    print(
+        f"[perf] thread={threading.current_thread().name} event={name} "
+        f"elapsed_ms={elapsed:.1f}{detail}",
+        file=out,
+    )
+
+
+def ensure_started() -> None:
+    """Call near process entry so t0 is close to CLI start when enabled late."""
+    trace = _current_trace()
+    if trace.enabled and not trace.marks:
+        trace.reset()
+        trace.mark("trace-enabled")

synapse/runtime/__init__.py

@@ -0,0 +1 @@
+"""Runtime execution, middleware, and safety services."""

synapse/runtime/async_runtime.py

@@ -0,0 +1,176 @@
+"""Process-lifetime asyncio loop for AsyncSqliteSaver + astream.
+
+LangGraph's ``AsyncSqliteSaver`` binds to the event loop that created it.
+TUI / CLI call sites are mostly synchronous and previously used
+``asyncio.run`` in a worker thread (a *new* loop every turn) — that cannot
+share an AsyncSqliteSaver.
+
+This module owns one background loop thread for the whole process:
+
+- open/setup AsyncSqliteSaver on that loop
+- schedule ``agent.astream`` coroutines onto the same loop
+- sync ``get_tuple`` (via LangGraph) still works from other threads via
+  ``run_coroutine_threadsafe``
+"""
+
+from __future__ import annotations
+
+import asyncio
+import atexit
+import threading
+import time
+from collections.abc import Coroutine
+from typing import Any, TypeVar
+
+T = TypeVar("T")
+
+
+class AsyncRuntime:
+    """Daemon thread running ``loop.run_forever()`` for checkpoint + astream."""
+
+    def __init__(self, *, name: str = "coding-async-runtime") -> None:
+        self._name = name
+        self._loop: asyncio.AbstractEventLoop | None = None
+        self._thread: threading.Thread | None = None
+        self._ready = threading.Event()
+        self._lock = threading.Lock()
+        self._closed = False
+        self._owned_conns: list[Any] = []
+
+    @property
+    def loop(self) -> asyncio.AbstractEventLoop:
+        self.start()
+        assert self._loop is not None
+        return self._loop
+
+    def start(self) -> None:
+        with self._lock:
+            if self._loop is not None and self._thread is not None and self._thread.is_alive():
+                return
+            if self._closed:
+                raise RuntimeError("AsyncRuntime is closed")
+            self._ready.clear()
+            self._thread = threading.Thread(
+                target=self._thread_main,
+                name=self._name,
+                daemon=True,
+            )
+            self._thread.start()
+        if not self._ready.wait(timeout=5.0):
+            raise RuntimeError("AsyncRuntime loop failed to start")
+
+    def _thread_main(self) -> None:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        self._loop = loop
+        self._ready.set()
+        try:
+            loop.run_forever()
+        finally:
+            try:
+                pending = asyncio.all_tasks(loop)
+                for task in pending:
+                    task.cancel()
+                if pending:
+                    loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
+            except Exception:  # noqa: BLE001
+                pass
+            loop.close()
+
+    def submit(self, coro: Coroutine[Any, Any, T]) -> asyncio.Future[T]:
+        """Schedule a coroutine on the runtime loop (thread-safe)."""
+        return asyncio.run_coroutine_threadsafe(coro, self.loop)
+
+    def run(self, coro: Coroutine[Any, Any, T], *, timeout: float | None = None) -> T:
+        """Block until the coroutine finishes on the runtime loop."""
+        return self.submit(coro).result(timeout=timeout)
+
+    def track_connection(self, conn: Any) -> None:
+        """Remember an async connection/client for shutdown."""
+        if conn not in self._owned_conns:
+            self._owned_conns.append(conn)
+
+    def close_connection(self, conn: Any) -> None:
+        """Close and forget one tracked async client on the runtime loop."""
+        try:
+            self._owned_conns.remove(conn)
+        except ValueError:
+            pass
+        close = getattr(conn, "aclose", None) or getattr(conn, "close", None)
+        if not callable(close):
+            return
+
+        async def _close() -> None:
+            result = close()
+            if asyncio.iscoroutine(result):
+                await result
+
+        try:
+            self.run(_close(), timeout=3.0)
+        except Exception:  # noqa: BLE001
+            pass
+
+    def close(self) -> None:
+        started = time.perf_counter()
+        with self._lock:
+            if self._closed:
+                return
+            self._closed = True
+            loop = self._loop
+            thread = self._thread
+        connection_count = len(self._owned_conns)
+        if loop is not None and loop.is_running():
+
+            async def _shutdown() -> None:
+                for conn in list(self._owned_conns):
+                    try:
+                        close = getattr(conn, "aclose", None) or getattr(conn, "close", None)
+                        if not callable(close):
+                            continue
+                        result = close()
+                        if asyncio.iscoroutine(result):
+                            await result
+                    except Exception:  # noqa: BLE001
+                        pass
+                self._owned_conns.clear()
+
+            try:
+                asyncio.run_coroutine_threadsafe(_shutdown(), loop).result(timeout=3.0)
+            except Exception:  # noqa: BLE001
+                pass
+            finally:
+                try:
+                    loop.call_soon_threadsafe(loop.stop)
+                except Exception:  # noqa: BLE001
+                    pass
+        if thread is not None and thread.is_alive():
+            thread.join(timeout=2.0)
+        self._loop = None
+        self._thread = None
+        try:
+            from synapse.observability.startup_trace import duration
+
+            duration("runtime.close", started, connections=connection_count)
+        except Exception:  # noqa: BLE001
+            pass
+
+
+_RUNTIME = AsyncRuntime()
+atexit.register(_RUNTIME.close)
+
+
+def get_async_runtime() -> AsyncRuntime:
+    """Process-global async runtime (lazy-started)."""
+    return _RUNTIME
+
+
+def reset_async_runtime_for_tests() -> AsyncRuntime:
+    """Close and replace the global runtime (tests only)."""
+    global _RUNTIME
+    try:
+        _RUNTIME.close()
+    except Exception:  # noqa: BLE001
+        pass
+    _RUNTIME = AsyncRuntime(name="coding-async-runtime-test")
+    atexit.register(_RUNTIME.close)
+    return _RUNTIME