nexus-coding-agent 0.1.0__py3-none-any.whl

nexus/infrastructure/checkpoint/postgres.py

@@ -0,0 +1,62 @@
+"""Lifecycle adapter for the official asynchronous PostgreSQL checkpointer."""
+
+from __future__ import annotations
+
+from contextlib import AbstractAsyncContextManager
+
+from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver
+from sqlalchemy.engine import make_url
+
+from nexus.errors import NexusError
+
+
+class PostgresCheckpointProvider:
+    """Own AsyncPostgresSaver creation, setup, and release."""
+
+    def __init__(self, database_url: str) -> None:
+        self._connection_string = _to_psycopg_connection_string(database_url)
+        self._context: AbstractAsyncContextManager[AsyncPostgresSaver] | None = None
+        self._checkpointer: AsyncPostgresSaver | None = None
+
+    async def setup(self) -> None:
+        if self._checkpointer is not None:
+            return
+        context = AsyncPostgresSaver.from_conn_string(self._connection_string)
+        self._context = context
+        try:
+            checkpointer = await context.__aenter__()
+            await checkpointer.setup()
+        except Exception as exc:
+            self._context = None
+            try:
+                await context.__aexit__(type(exc), exc, exc.__traceback__)
+            except Exception:
+                pass
+            raise NexusError(
+                "Nexus could not initialize durable graph checkpoints.",
+                code="CHECKPOINT_SETUP_ERROR",
+                retryable=True,
+            ) from exc
+        self._checkpointer = checkpointer
+
+    def get_checkpointer(self) -> object:
+        if self._checkpointer is None:
+            raise RuntimeError("CheckpointProvider.setup() must run before use.")
+        return self._checkpointer
+
+    async def close(self) -> None:
+        context = self._context
+        self._context = None
+        self._checkpointer = None
+        if context is not None:
+            await context.__aexit__(None, None, None)
+
+
+def _to_psycopg_connection_string(database_url: str) -> str:
+    url = make_url(database_url)
+    if url.get_backend_name() != "postgresql":
+        raise NexusError(
+            "The checkpoint database must use PostgreSQL.",
+            code="CHECKPOINT_CONFIGURATION_ERROR",
+        )
+    return url.set(drivername="postgresql").render_as_string(hide_password=False)

nexus/infrastructure/database.py

@@ -0,0 +1,39 @@
+"""Day 1 PostgreSQL engine bootstrap and connectivity check."""
+
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import (
+    AsyncEngine,
+    AsyncSession,
+    async_sessionmaker,
+    create_async_engine,
+)
+
+
+class DatabaseBootstrap:
+    """Own the Day 1 async engine without introducing business persistence."""
+
+    def __init__(self, database_url: str) -> None:
+        self._engine: AsyncEngine = create_async_engine(
+            database_url,
+            connect_args={"timeout": 5},
+            hide_parameters=True,
+            pool_timeout=5,
+        )
+        self._session_factory = async_sessionmaker(self._engine, expire_on_commit=False)
+
+    @property
+    def session_factory(self) -> async_sessionmaker[AsyncSession]:
+        """Provide transaction-scoped sessions to infrastructure adapters."""
+
+        return self._session_factory
+
+    async def check_connection(self) -> None:
+        """Open a connection and execute the smallest useful smoke query."""
+
+        async with self._engine.connect() as connection:
+            await connection.execute(text("SELECT 1"))
+
+    async def close(self) -> None:
+        """Dispose the engine pool and any checked-in connections."""
+
+        await self._engine.dispose()

nexus/infrastructure/embedding.py

@@ -0,0 +1,61 @@
+"""Independent LangChain OpenAI-compatible embedding adapter."""
+
+from collections.abc import Sequence
+from math import isfinite
+
+from langchain_openai import OpenAIEmbeddings
+
+from nexus.config.models import RuntimeConfig
+from nexus.domain.context import EmbeddingConfig
+from nexus.errors import ContextError
+
+
+class OpenAICompatibleEmbeddingGateway:
+    def __init__(self, config: RuntimeConfig) -> None:
+        config.require_embedding()
+        self._config = EmbeddingConfig(
+            config.embedding_provider,
+            config.embedding_model,
+            config.embedding_dimension,
+        )
+        self._client = OpenAIEmbeddings(
+            model=config.embedding_model,
+            base_url=config.embedding_base_url,
+            api_key=config.embedding_api_key,
+            dimensions=config.embedding_dimension,
+            check_embedding_ctx_length=False,
+        )
+
+    @property
+    def config(self) -> EmbeddingConfig:
+        return self._config
+
+    async def embed_documents(self, texts: Sequence[str]) -> tuple[tuple[float, ...], ...]:
+        if not texts:
+            return ()
+        try:
+            vectors = await self._client.aembed_documents(list(texts))
+            return validate_vectors(vectors, len(texts), self.config.dimension)
+        except Exception as exc:
+            raise ContextError(
+                "Embedding request failed or returned invalid vectors.",
+                code="EMBEDDING_FAILED",
+                retryable=True,
+            ) from exc
+
+    async def embed_query(self, text: str) -> tuple[float, ...]:
+        return (await self.embed_documents((text,)))[0]
+
+
+def validate_vectors(
+    vectors: Sequence[Sequence[float]],
+    count: int,
+    dimension: int,
+) -> tuple[tuple[float, ...], ...]:
+    result = tuple(tuple(float(value) for value in vector) for vector in vectors)
+    if len(result) != count or any(
+        len(vector) != dimension or not all(isfinite(value) for value in vector) or not any(vector)
+        for vector in result
+    ):
+        raise ContextError("Invalid embedding shape or values.", code="EMBEDDING_FAILED")
+    return result

nexus/infrastructure/graph/__init__.py

@@ -0,0 +1,6 @@
+"""Concrete graph runtime adapters."""
+
+from nexus.infrastructure.graph.langgraph_runtime import LangGraphRuntime
+
+__all__ = ["LangGraphRuntime"]
+