hexgate 0.2.3__tar.gz → 0.2.4__tar.gz

{hexgate-0.2.3 → hexgate-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hexgate
-Version: 0.2.3
+Version: 0.2.4
 Summary: Hexgate — authorization infrastructure for AI agents (agent runtime + cloud client).
 License-Expression: MIT
 Requires-Python: >=3.13
@@ -223,6 +223,31 @@ make dashboard-install      # pnpm install inside platform/dashboard/
 
 Then open http://localhost:5173/playground — type a message, watch the live stream of tool calls and policy decisions from your local agent.
 
+### Control-plane database (SQLite / Postgres)
+
+`make platform-api` uses a local **SQLite** file — zero setup, fine for
+dev and the test suite. Set `DATABASE_URL` to run on **Postgres** instead
+(what deployments use); bare `postgres://` URLs are normalized to the
+`asyncpg` driver. A local Postgres is in the dev compose:
+
+```bash
+make platform-api-pg      # starts Postgres (Docker) + runs the API against it
+# equivalent to:
+make postgres-up          # start Postgres, wait until healthy
+DATABASE_URL=postgresql+asyncpg://hexgate:hexgate-dev-password@localhost:5433/hexgate make platform-api
+make postgres-reset       # wipe ONLY the Postgres data volume
+```
+
+No migration system: the schema is created with `create_all`, so a model
+change means resetting the volume (`make postgres-reset`), not migrating —
+data is treated as disposable. A managed Postgres (e.g. Scaleway) needs SSL
+in the DSN, e.g. `…/hexgate?ssl=require`.
+
+`DATABASE_URL` is read from the real environment or `platform/api/.env`
+(see `.env.sample`). The opt-in `tests/test_postgres_smoke.py` is the only
+test that exercises the Postgres path (the rest run on SQLite); it runs
+when `DATABASE_URL` points at Postgres.
+
 ### Audit log (ClickHouse)
 
 Policy decisions are written to a local ClickHouse instance for the audit dashboard. Requires Docker.

{hexgate-0.2.3 → hexgate-0.2.4}/README.md

@@ -184,6 +184,31 @@ make dashboard-install      # pnpm install inside platform/dashboard/
 
 Then open http://localhost:5173/playground — type a message, watch the live stream of tool calls and policy decisions from your local agent.
 
+### Control-plane database (SQLite / Postgres)
+
+`make platform-api` uses a local **SQLite** file — zero setup, fine for
+dev and the test suite. Set `DATABASE_URL` to run on **Postgres** instead
+(what deployments use); bare `postgres://` URLs are normalized to the
+`asyncpg` driver. A local Postgres is in the dev compose:
+
+```bash
+make platform-api-pg      # starts Postgres (Docker) + runs the API against it
+# equivalent to:
+make postgres-up          # start Postgres, wait until healthy
+DATABASE_URL=postgresql+asyncpg://hexgate:hexgate-dev-password@localhost:5433/hexgate make platform-api
+make postgres-reset       # wipe ONLY the Postgres data volume
+```
+
+No migration system: the schema is created with `create_all`, so a model
+change means resetting the volume (`make postgres-reset`), not migrating —
+data is treated as disposable. A managed Postgres (e.g. Scaleway) needs SSL
+in the DSN, e.g. `…/hexgate?ssl=require`.
+
+`DATABASE_URL` is read from the real environment or `platform/api/.env`
+(see `.env.sample`). The opt-in `tests/test_postgres_smoke.py` is the only
+test that exercises the Postgres path (the rest run on SQLite); it runs
+when `DATABASE_URL` points at Postgres.
+
 ### Audit log (ClickHouse)
 
 Policy decisions are written to a local ClickHouse instance for the audit dashboard. Requires Docker.

{hexgate-0.2.3 → hexgate-0.2.4}/hexgate/adapters/langchain/agent.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, AsyncIterator, Iterator
+from typing import TYPE_CHECKING, Any, AsyncIterator, Iterator, Literal
 
 from langchain_core.runnables import RunnableConfig
 from langfuse import get_client, propagate_attributes
@@ -134,10 +134,10 @@ class HexgateLangchainAgent:
     async def astream_events(
         self,
         input: dict[str, Any],
-        version: str,
         *,
         user: User,
         config: RunnableConfig | None = None,
+        version: Literal["v1", "v2"] = "v2",
         **kwargs: Any,
     ) -> AsyncIterator[dict[str, Any]]:
         """Stream the agent events asynchronously inside a User scope."""
@@ -145,7 +145,10 @@ class HexgateLangchainAgent:
         async with user:
             with propagate_attributes(**self._propagate_kwargs(user, "astream_events")):
                 async for event in self._agent.astream_events(
-                    input, version, config=self._with_callbacks(config), **kwargs
+                    input,
+                    config=self._with_callbacks(config),
+                    version=version,
+                    **kwargs,
                 ):
                     yield event
 

{hexgate-0.2.3 → hexgate-0.2.4}/hexgate/agents/factory.py

@@ -190,6 +190,13 @@ def extract_input_text(input: AgentInput) -> str:
     return _extract_query_from_messages(input)
 
 
+# One-shot dedupe for the "local agent with active User scope" warning
+# inside `_resolve_user_facts`. The dashboard playground hits this once
+# per turn (and the platform-served sessions never hit it at all), so
+# without a flag the warning floods the log on every chat message.
+_warned_local_agent_user_scope: bool = False
+
+
 def _resolve_user_facts(agent: HexgateAgent) -> dict[str, list[str | int]] | None:
     """Lazily attenuate when a :class:`User` scope is active.
 
@@ -206,14 +213,22 @@ def _resolve_user_facts(agent: HexgateAgent) -> dict[str, list[str | int]] | Non
     client = agent.hexgate_client
     if client is None:
         # Local agent or test stub — User scope is set but there's nothing to
-        # attenuate against. Surface a single warning so devs see why their
-        # `requires_user` predicate isn't firing on a local-loaded agent.
-        import logging
-
-        logging.getLogger(__name__).warning(
-            "User scope active but agent has no hexgate_client; "
-            "biscuit_facts will be empty (use load_hexgate_agent for attenuation)"
-        )
+        # attenuate against. Surface a *single* warning so devs see why their
+        # `requires_user` predicate isn't firing on a local-loaded agent, then
+        # stay quiet: every subsequent turn would re-fire the same message
+        # otherwise (3-5x per chat session in the dashboard playground was
+        # the symptom).
+        global _warned_local_agent_user_scope
+        if not _warned_local_agent_user_scope:
+            import logging
+
+            logging.getLogger(__name__).warning(
+                "User scope active but agent has no hexgate_client; "
+                "biscuit_facts will be empty (use load_hexgate_agent for "
+                "attenuation). Subsequent occurrences in this process are "
+                "suppressed."
+            )
+            _warned_local_agent_user_scope = True
         return None
     from hexgate.cloud.attenuate import attenuate_for_user
     from hexgate.cloud.biscuit import (

{hexgate-0.2.3 → hexgate-0.2.4}/hexgate/audit.py

@@ -149,7 +149,13 @@ class AuditSender:
         # latch onto the first loop that drives them and reject any other
         # (e.g. a second asyncio.run()). Build them eagerly so configure()
         # stays sync, but track the loop and rebuild if it rotates.
-        self._loop: asyncio.AbstractEventLoop | None = None
+        #
+        # Capture the build-time loop so emit() can reach it from an executor
+        # thread (a sync tool under run_in_executor has no loop of its own).
+        try:
+            self._loop: asyncio.AbstractEventLoop | None = asyncio.get_running_loop()
+        except RuntimeError:
+            self._loop = None
         self._semaphore = asyncio.Semaphore(max_in_flight)
         self._client: httpx.AsyncClient | None = self._new_client()
         self._tasks: set[asyncio.Task[None]] = set()
@@ -182,11 +188,31 @@ class AuditSender:
         try:
             loop = asyncio.get_running_loop()
         except RuntimeError:
-            if not self._warned_no_loop:
-                _log.warning("audit emit called without a running event loop; skipping")
-                self._warned_no_loop = True
+            # Called off-loop (sync tool on a run_in_executor thread): route
+            # to the build-time loop instead of dropping the event.
+            loop = self._loop
+            if loop is None or loop.is_closed():
+                if not self._warned_no_loop:
+                    _log.warning(
+                        "audit emit called with no running loop and no live "
+                        "bound loop; skipping"
+                    )
+                    self._warned_no_loop = True
+                return
+            try:
+                loop.call_soon_threadsafe(self._spawn_send, event)
+            except RuntimeError:
+                pass  # loop torn down between the is_closed() check and the call
             return
         self._ensure_loop_state(loop)
+        self._spawn_send(event)
+
+    def _spawn_send(self, event: AuditEvent) -> None:
+        """Create the send task. MUST run on the bound loop's thread —
+        ``create_task`` and the loop-bound semaphore require the running loop.
+        Reached on-loop from :meth:`emit`, or via ``call_soon_threadsafe``."""
+        if self._closing or self._client is None:
+            return
         if self._semaphore.locked():
             self._dropped += 1
             if self._dropped % 100 == 1:

{hexgate-0.2.3 → hexgate-0.2.4}/hexgate/cli/_common.py

@@ -209,13 +209,11 @@ def build_runtime_from_local_agent(
     """
     import os
 
-    import yaml
-
     from hexgate.agents.factory import enforce_policy
     from hexgate.cli.register.manifest import create_manifest
     from hexgate.cli.register.register import post_manifest
     from hexgate.cloud.client import HexgateClient, HexgateConfig
-    from hexgate.security.policy_set import load_policy_set_from_dict
+    from hexgate.security.binding import platform_policy_from_payload
     from hexgate.tracing.langfuse import get_langfuse_handler
 
     manifest = create_manifest(agent_obj, description=description)
@@ -239,7 +237,7 @@ def build_runtime_from_local_agent(
 
     config = HexgateConfig.from_env()
     client = HexgateClient(config)
-    payload, _etag = client.get_agent(agent_name)
+    payload, initial_etag = client.get_agent(agent_name)
     if payload is None:
         # Invariant: no If-None-Match was sent, so a 304 is impossible.
         # Raise so `python -O` can't strip the check.
@@ -248,10 +246,22 @@ def build_runtime_from_local_agent(
             "on initial fetch (no If-None-Match was sent)"
         )
 
-    policy_payload = yaml.safe_load(payload["policy_yaml"]) or {}
-    policy = load_policy_set_from_dict(policy_payload)
+    # platform_policy_from_payload returns the canonical (engine, source)
+    # pair: handles signed-bundle vs pydantic fallback, and seeds the
+    # PlatformPolicySource with the bundle + ETag so the next refresh is
+    # a 304 unless policy changed. Without the source kwarg, refresh_policy()
+    # at the top of every stream_agent() is a no-op and dashboard edits
+    # only land at the next `hexgate serve` restart.
+    policy, refresh_source = platform_policy_from_payload(
+        client, agent_name, payload, initial_etag
+    )
 
-    enforced = enforce_policy(agent_obj, policy, approval_handler=approval_handler)
+    enforced = enforce_policy(
+        agent_obj,
+        policy,
+        approval_handler=approval_handler,
+        source=refresh_source,
+    )
 
     # Fresh handler for the streaming layer. The user's create_agent() call
     # built its own handler but discarded it; we make a new one bound to

{hexgate-0.2.3 → hexgate-0.2.4}/hexgate/cli/register/hexgate.py

@@ -28,7 +28,7 @@ def create_hexgate_manifest(
     return AgentManifest(
         name=agent.name,
         description=description,
-        framework=AgentFramework.FORTIFY,
+        framework=AgentFramework.HEXGATE,
         model=_extract_model(agent.model),
         system_prompt=_extract_system_prompt(agent.system_prompt),
         tools=[_to_tool_definition(t) for t in agent.tools],

{hexgate-0.2.3 → hexgate-0.2.4}/hexgate/cli/register/models.py

@@ -32,7 +32,7 @@ else:
 class AgentFramework(StrEnum):
     """Enum for the framework of an agent."""
 
-    FORTIFY = "hexgate"
+    HEXGATE = "hexgate"
     PYDANTIC_AI = "pydantic-ai"
     LANGCHAIN = "langchain"
     GOOGLE = "google"

{hexgate-0.2.3 → hexgate-0.2.4}/hexgate/runtime/context.py

@@ -9,7 +9,6 @@ from collections.abc import Iterator
 from contextlib import contextmanager
 from contextvars import ContextVar, Token
 from dataclasses import dataclass
-from typing import Any
 
 from pydantic import BaseModel, ConfigDict, PrivateAttr
 
@@ -96,26 +95,30 @@ class User(BaseModel):
     session_id: str | None = None
     ttl_seconds: int | None = None
 
-    # Stack so the same User instance survives nested ``async with`` blocks.
-    _tokens: list[Any] = PrivateAttr(default_factory=list)
+    # Stack of shadowed values (supports nested scopes). We save/restore via
+    # set() rather than reset(token): async-generator finalizers run __aexit__
+    # in a different Context, where a token reset would raise — set() doesn't.
+    _saved: list["User | None"] = PrivateAttr(default_factory=list)
 
     async def __aenter__(self) -> "User":
-        self._tokens.append(_CURRENT_USER.set(self))
+        self._saved.append(_CURRENT_USER.get())
+        _CURRENT_USER.set(self)
         return self
 
     async def __aexit__(self, *_: object) -> None:
-        if self._tokens:
-            _CURRENT_USER.reset(self._tokens.pop())
+        if self._saved:
+            _CURRENT_USER.set(self._saved.pop())
 
     @contextmanager
     def sync_scope(self) -> Iterator["User"]:
         """Sync mirror of ``async with self`` for sync entry points."""
-        self._tokens.append(_CURRENT_USER.set(self))
+        self._saved.append(_CURRENT_USER.get())
+        _CURRENT_USER.set(self)
         try:
             yield self
         finally:
-            if self._tokens:
-                _CURRENT_USER.reset(self._tokens.pop())
+            if self._saved:
+                _CURRENT_USER.set(self._saved.pop())
 
 
 _CURRENT_USER: ContextVar[User | None] = ContextVar(

{hexgate-0.2.3 → hexgate-0.2.4}/hexgate/security/binding.py

@@ -170,6 +170,22 @@ def platform_policy_from_payload(
             "Refusing to fall back to the pydantic engine."
         )
     else:
+        # Loud one-shot signal (fires at load time, not per turn) so an
+        # operator running `hexgate serve` doesn't silently get the
+        # pydantic engine when they expected the production-shaped
+        # WASM path. Common cause: `opa` not installed on the platform
+        # host — see compile_bundle() in platform/api/services.py, which
+        # logs "opa not on PATH" on the server side too.
+        logger.warning(
+            "policy for %r served without a WASM bundle — falling back to "
+            "the pydantic engine. Decisions are equivalent (parity-tested), "
+            "but signature verification and signed-artifact distribution "
+            "are off. Install `opa` on the platform host and re-save the "
+            "policy to get the WASM path; set %s=true to refuse the "
+            "fallback entirely.",
+            agent_name,
+            _REQUIRE_SIGNATURE_ENV_VAR,
+        )
         policy = load_policy_set_from_dict(
             yaml.safe_load(payload.get("policy_yaml") or "") or {}
         )

{hexgate-0.2.3 → hexgate-0.2.4}/hexgate.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hexgate
-Version: 0.2.3
+Version: 0.2.4
 Summary: Hexgate — authorization infrastructure for AI agents (agent runtime + cloud client).
 License-Expression: MIT
 Requires-Python: >=3.13
@@ -223,6 +223,31 @@ make dashboard-install      # pnpm install inside platform/dashboard/
 
 Then open http://localhost:5173/playground — type a message, watch the live stream of tool calls and policy decisions from your local agent.
 
+### Control-plane database (SQLite / Postgres)
+
+`make platform-api` uses a local **SQLite** file — zero setup, fine for
+dev and the test suite. Set `DATABASE_URL` to run on **Postgres** instead
+(what deployments use); bare `postgres://` URLs are normalized to the
+`asyncpg` driver. A local Postgres is in the dev compose:
+
+```bash
+make platform-api-pg      # starts Postgres (Docker) + runs the API against it
+# equivalent to:
+make postgres-up          # start Postgres, wait until healthy
+DATABASE_URL=postgresql+asyncpg://hexgate:hexgate-dev-password@localhost:5433/hexgate make platform-api
+make postgres-reset       # wipe ONLY the Postgres data volume
+```
+
+No migration system: the schema is created with `create_all`, so a model
+change means resetting the volume (`make postgres-reset`), not migrating —
+data is treated as disposable. A managed Postgres (e.g. Scaleway) needs SSL
+in the DSN, e.g. `…/hexgate?ssl=require`.
+
+`DATABASE_URL` is read from the real environment or `platform/api/.env`
+(see `.env.sample`). The opt-in `tests/test_postgres_smoke.py` is the only
+test that exercises the Postgres path (the rest run on SQLite); it runs
+when `DATABASE_URL` points at Postgres.
+
 ### Audit log (ClickHouse)
 
 Policy decisions are written to a local ClickHouse instance for the audit dashboard. Requires Docker.

{hexgate-0.2.3 → hexgate-0.2.4}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "setuptools.build_meta"
 # 0.2.0 (the original package name was taken on PyPI by a 2014
 # abandoned project; the team consolidated on `hexgate` for everything).
 name = "hexgate"
-version = "0.2.3"
+version = "0.2.4"
 description = "Hexgate — authorization infrastructure for AI agents (agent runtime + cloud client)."
 readme = "README.md"
 license = "MIT"