dbl-gateway 0.3.2__py3-none-any.whl

dbl_gateway/providers/openai.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import httpx
+
+from .errors import ProviderError
+
+
+def execute(message: str, model_id: str) -> str:
+    api_key = os.getenv("OPENAI_API_KEY", "").strip()
+    if not api_key:
+        raise ProviderError("missing OpenAI credentials")
+    headers = {"Authorization": f"Bearer {api_key}"}
+    if _use_responses(model_id):
+        return _execute_responses(message, model_id, headers)
+    return _execute_chat(message, model_id, headers)
+
+
+def _use_responses(model_id: str) -> bool:
+    if model_id.startswith("gpt-5"):
+        return True
+    return model_id in _responses_models()
+
+
+def _responses_models() -> list[str]:
+    raw = os.getenv("OPENAI_RESPONSES_MODEL_IDS", "").strip()
+    if not raw:
+        return ["gpt-5.2"]
+    return [item.strip() for item in raw.split(",") if item.strip()]
+
+
+def _execute_responses(message: str, model_id: str, headers: dict[str, str]) -> str:
+    payload: dict[str, Any] = {
+        "model": model_id,
+        "input": [
+            {
+                "role": "user",
+                "content": [{"type": "input_text", "text": message}],
+            }
+        ],
+    }
+    with httpx.Client(timeout=30.0) as client:
+        resp = client.post("https://api.openai.com/v1/responses", json=payload, headers=headers)
+        if resp.status_code >= 400:
+            _raise_openai(resp, "openai.responses failed")
+        data = resp.json()
+    return _parse_response_text(data)
+
+
+def _execute_chat(message: str, model_id: str, headers: dict[str, str]) -> str:
+    payload: dict[str, Any] = {
+        "model": model_id,
+        "messages": [{"role": "user", "content": message}],
+        "temperature": 0.2,
+        "max_tokens": 256,
+    }
+    with httpx.Client(timeout=30.0) as client:
+        resp = client.post("https://api.openai.com/v1/chat/completions", json=payload, headers=headers)
+        if resp.status_code >= 400:
+            _raise_openai(resp, "openai.chat failed")
+        data = resp.json()
+    return _parse_chat_text(data)
+
+
+def _parse_chat_text(data: dict[str, Any]) -> str:
+    choices = data.get("choices", [])
+    if not choices:
+        return ""
+    message = choices[0].get("message", {})
+    content = message.get("content")
+    return content if isinstance(content, str) else ""
+
+
+def _parse_response_text(data: dict[str, Any]) -> str:
+    outputs = data.get("output", [])
+    parts: list[str] = []
+    for item in outputs:
+        content = item.get("content", [])
+        for entry in content:
+            if entry.get("type") == "output_text":
+                text = entry.get("text")
+                if isinstance(text, str):
+                    parts.append(text)
+    return "\n".join(parts)
+
+
+def _raise_openai(resp: httpx.Response, where: str) -> None:
+    code = None
+    msg = None
+    try:
+        j = resp.json()
+        err = j.get("error") if isinstance(j, dict) else None
+        if isinstance(err, dict):
+            code = err.get("code")
+            msg = err.get("message")
+    except Exception:
+        pass
+    detail = msg or resp.text[:500]
+    raise ProviderError(
+        f"{where}: {detail}",
+        status_code=resp.status_code,
+        code=str(code) if code else None,
+    )

dbl_gateway/store/__init__.py

@@ -0,0 +1 @@
+__all__ = ["base", "factory", "sqlite"]

dbl_gateway/store/base.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from typing import Protocol
+
+from ..models import EventRecord, Snapshot
+
+# Deprecated: moved to dbl_gateway.ports.store_port
+
+
+class StorePort(Protocol):
+    def append(
+        self,
+        *,
+        kind: str,
+        lane: str,
+        actor: str,
+        intent_type: str,
+        stream_id: str,
+        correlation_id: str,
+        payload: dict[str, object],
+    ) -> EventRecord:
+        ...
+
+    def snapshot(
+        self,
+        *,
+        limit: int,
+        offset: int,
+        stream_id: str | None = None,
+        lane: str | None = None,
+    ) -> Snapshot:
+        ...
+
+    def close(self) -> None:
+        ...

dbl_gateway/store/factory.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from ..adapters.store_adapter_sqlite import SQLiteStoreAdapter
+from ..ports.store_port import StorePort
+
+
+def create_store(db_path: Path | None = None) -> StorePort:
+    path = db_path or Path(os.getenv("DBL_GATEWAY_DB", ".\\data\\trail.sqlite"))
+    return SQLiteStoreAdapter.from_path(path)

dbl_gateway/store/sqlite.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from ..digest import event_digest, v_digest
+
+from ..models import EventRecord, Snapshot
+
+
+class SQLiteStore:
+    def __init__(self, db_path: Path) -> None:
+        self._db_path = db_path
+        self._db_path.parent.mkdir(parents=True, exist_ok=True)
+        self._conn = sqlite3.connect(self._db_path, check_same_thread=False)
+        self._conn.execute("PRAGMA journal_mode=WAL;")
+        self._conn.execute("PRAGMA synchronous=NORMAL;")
+        self._init_schema()
+
+    def close(self) -> None:
+        self._conn.close()
+
+    def _init_schema(self) -> None:
+        with self._conn:
+            self._conn.execute(
+                """
+                CREATE TABLE IF NOT EXISTS events (
+                    idx INTEGER PRIMARY KEY AUTOINCREMENT,
+                    kind TEXT NOT NULL,
+                    lane TEXT NOT NULL,
+                    actor TEXT NOT NULL,
+                    intent_type TEXT NOT NULL,
+                    stream_id TEXT NOT NULL,
+                    correlation_id TEXT NOT NULL,
+                    payload_json TEXT NOT NULL,
+                    digest TEXT NOT NULL,
+                    canon_len INTEGER NOT NULL,
+                    created_at_utc TEXT NOT NULL
+                )
+                """
+            )
+            self._ensure_column("events", "lane", "TEXT NOT NULL DEFAULT 'unknown'")
+            self._ensure_column("events", "actor", "TEXT NOT NULL DEFAULT 'unknown'")
+            self._ensure_column("events", "intent_type", "TEXT NOT NULL DEFAULT ''")
+            self._ensure_column("events", "stream_id", "TEXT NOT NULL DEFAULT 'default'")
+            self._conn.execute("CREATE INDEX IF NOT EXISTS events_stream_id ON events(stream_id)")
+            self._conn.execute("CREATE INDEX IF NOT EXISTS events_lane ON events(lane)")
+            self._conn.execute("CREATE INDEX IF NOT EXISTS events_kind ON events(kind)")
+            self._conn.execute(
+                "CREATE INDEX IF NOT EXISTS events_correlation_id ON events(correlation_id)"
+            )
+    
+    def _ensure_column(self, table: str, column: str, ddl: str) -> None:
+        cols = self._conn.execute(f"PRAGMA table_info({table})").fetchall()
+        existing = {row[1] for row in cols}
+        if column in existing:
+            return
+        self._conn.execute(f"ALTER TABLE {table} ADD COLUMN {column} {ddl}")
+
+    def append(
+        self,
+        *,
+        kind: str,
+        lane: str,
+        actor: str,
+        intent_type: str,
+        stream_id: str,
+        correlation_id: str,
+        payload: dict[str, object],
+    ) -> EventRecord:
+        digest_ref, canon_len = event_digest(kind, correlation_id, payload)
+        payload_json = json.dumps(
+            payload,
+            ensure_ascii=True,
+            sort_keys=True,
+            separators=(",", ":"),
+            allow_nan=False,
+        )
+        created_at = datetime.now(timezone.utc).isoformat()
+        with self._conn:
+            self._conn.execute(
+                """
+                INSERT INTO events (
+                    kind,
+                    lane,
+                    actor,
+                    intent_type,
+                    stream_id,
+                    correlation_id,
+                    payload_json,
+                    digest,
+                    canon_len,
+                    created_at_utc
+                )
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    kind,
+                    lane,
+                    actor,
+                    intent_type,
+                    stream_id,
+                    correlation_id,
+                    payload_json,
+                    digest_ref,
+                    canon_len,
+                    created_at,
+                ),
+            )
+            cur = self._conn.execute("SELECT idx FROM events WHERE rowid = last_insert_rowid()")
+            row = cur.fetchone()
+            idx = int(row[0]) if row else 0
+        index = max(0, idx - 1)
+        return {
+            "index": index,
+            "kind": kind,
+            "lane": lane,
+            "actor": actor,
+            "intent_type": intent_type,
+            "stream_id": stream_id,
+            "correlation_id": correlation_id,
+            "payload": payload,
+            "digest": digest_ref,
+            "canon_len": canon_len,
+        }
+
+    def snapshot(
+        self,
+        *,
+        limit: int,
+        offset: int,
+        stream_id: str | None = None,
+        lane: str | None = None,
+    ) -> Snapshot:
+        events = self._fetch_events(limit=limit, offset=offset, stream_id=stream_id, lane=lane)
+        length = self._count_events()
+        v_digest_value = self._v_digest_all()
+        return {
+            "length": length,
+            "offset": offset,
+            "limit": limit,
+            "v_digest": v_digest_value,
+            "events": events,
+        }
+
+    def _fetch_events(
+        self,
+        *,
+        limit: int,
+        offset: int,
+        stream_id: str | None,
+        lane: str | None,
+    ) -> list[EventRecord]:
+        query = (
+            "SELECT idx, kind, lane, actor, intent_type, stream_id, correlation_id, "
+            "payload_json, digest, canon_len FROM events"
+        )
+        params: list[Any] = []
+        filters: list[str] = []
+        if stream_id:
+            filters.append("stream_id = ?")
+            params.append(stream_id)
+        if lane:
+            filters.append("lane = ?")
+            params.append(lane)
+        if filters:
+            query += " WHERE " + " AND ".join(filters)
+        query += " ORDER BY idx ASC LIMIT ? OFFSET ?"
+        params.extend([limit, offset])
+        rows = self._conn.execute(query, params).fetchall()
+        events: list[EventRecord] = []
+        for row in rows:
+            payload = json.loads(row[7])
+            events.append(
+                {
+                    "index": max(0, int(row[0]) - 1),
+                    "kind": str(row[1]),
+                    "lane": str(row[2]),
+                    "actor": str(row[3]),
+                    "intent_type": str(row[4]),
+                    "stream_id": str(row[5]),
+                    "correlation_id": str(row[6]),
+                    "payload": payload,
+                    "digest": str(row[8]),
+                    "canon_len": int(row[9]),
+                }
+            )
+        return events
+
+    def _count_events(self) -> int:
+        row = self._conn.execute("SELECT COUNT(*) FROM events").fetchone()
+        return int(row[0]) if row else 0
+
+    def _v_digest_all(self) -> str:
+        rows = self._conn.execute("SELECT idx, digest FROM events ORDER BY idx ASC").fetchall()
+        indexed = [(max(0, int(idx) - 1), str(digest)) for idx, digest in rows]
+        return v_digest(indexed)

dbl_gateway/wire_contract.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from typing import Any, Mapping, TypedDict
+
+
+INTERFACE_VERSION = 1
+
+
+class IntentPayload(TypedDict):
+    stream_id: str
+    lane: str
+    actor: str
+    intent_type: str
+    payload: dict[str, Any]
+    requested_model_id: str | None
+
+
+class IntentEnvelope(TypedDict):
+    interface_version: int
+    correlation_id: str
+    payload: IntentPayload
+
+
+def parse_intent_envelope(body: Mapping[str, Any]) -> IntentEnvelope:
+    interface_version = body.get("interface_version")
+    if not isinstance(interface_version, int):
+        raise ValueError("interface_version must be an int")
+    if interface_version != INTERFACE_VERSION:
+        raise ValueError("unsupported interface_version")
+    correlation_id = body.get("correlation_id")
+    if not isinstance(correlation_id, str) or correlation_id.strip() == "":
+        raise ValueError("correlation_id must be a non-empty string")
+    payload = body.get("payload")
+    if not isinstance(payload, Mapping):
+        raise ValueError("payload must be an object")
+    stream_id = payload.get("stream_id")
+    lane = payload.get("lane")
+    actor = payload.get("actor")
+    intent_type = payload.get("intent_type")
+    inner_payload = payload.get("payload")
+    if not isinstance(stream_id, str) or stream_id.strip() == "":
+        raise ValueError("payload.stream_id must be a non-empty string")
+    if not isinstance(lane, str) or lane.strip() == "":
+        raise ValueError("payload.lane must be a non-empty string")
+    if not isinstance(actor, str) or actor.strip() == "":
+        raise ValueError("payload.actor must be a non-empty string")
+    if not isinstance(intent_type, str) or intent_type.strip() == "":
+        raise ValueError("payload.intent_type must be a non-empty string")
+    if not isinstance(inner_payload, Mapping):
+        raise ValueError("payload.payload must be an object")
+    requested_model_id = payload.get("requested_model_id")
+    if requested_model_id is not None and not isinstance(requested_model_id, str):
+        raise ValueError("payload.requested_model_id must be a string")
+    return {
+        "interface_version": interface_version,
+        "correlation_id": correlation_id.strip(),
+        "payload": {
+            "stream_id": stream_id.strip(),
+            "lane": lane.strip(),
+            "actor": actor.strip(),
+            "intent_type": intent_type.strip(),
+            "payload": dict(inner_payload),
+            "requested_model_id": requested_model_id.strip() if isinstance(requested_model_id, str) else None,
+        },
+    }

dbl_gateway-0.3.2.dist-info/METADATA

@@ -0,0 +1,78 @@
+Metadata-Version: 2.4
+Name: dbl-gateway
+Version: 0.3.2
+Summary: DBL Gateway
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dbl-core<0.4.0,>=0.3.2
+Requires-Dist: dbl-policy<0.2.0,>=0.1.0
+Requires-Dist: dbl-main<0.4.0,>=0.3.0
+Requires-Dist: dbl-ingress<0.2.0,>=0.1.1
+Requires-Dist: kl-kernel-logic<0.6.0,>=0.5.0
+Requires-Dist: fastapi>=0.110.0
+Requires-Dist: uvicorn>=0.27.0
+Requires-Dist: httpx>=0.27.0
+Provides-Extra: dev
+Requires-Dist: pytest<9,>=8; extra == "dev"
+Requires-Dist: ruff<1,>=0.5; extra == "dev"
+Requires-Dist: mypy<2,>=1.10; extra == "dev"
+Requires-Dist: dbl-reference>=0.2.0; extra == "dev"
+Provides-Extra: oidc
+Requires-Dist: python-jose[cryptography]<4,>=3.3; extra == "oidc"
+Dynamic: license-file
+
+# DBL Gateway 0.3.2
+
+Authoritative DBL and KL gateway. This service is the single writer for append-only trails,
+applies policy via dbl-policy, and executes via kl-kernel-logic. UI and boundary services
+consume its snapshots and emit INTENT only.
+
+This release stabilizes the 0.3.x stackline and does not introduce new wire contracts.
+
+Compatible stack versions:
+- dbl-core==0.3.2
+- dbl-policy==0.1.0
+- dbl-main==0.3.0
+- kl-kernel-logic==0.5.0
+
+## Quickstart (PowerShell)
+
+```powershell
+py -3.11 -m venv .venv
+.venv\Scripts\Activate.ps1
+python -m pip install -e ".[dev]"
+```
+
+Run the gateway:
+```powershell
+dbl-gateway serve --db .\data\trail.sqlite --host 127.0.0.1 --port 8010
+```
+
+Run with uvicorn:
+```powershell
+$env:DBL_GATEWAY_DB=".\data\trail.sqlite"
+py -3.11 -m uvicorn dbl_gateway.app:app --host 127.0.0.1 --port 8010
+```
+
+## Endpoints
+
+Write:
+- POST `/ingress/intent`
+
+Read:
+- GET `/snapshot`
+- GET `/capabilities`
+- GET `/healthz`
+
+## Environment contract
+
+See `docs/env_contract.md`.
+
+## Notes
+
+- The gateway is the only component that performs governance and execution.
+- All stabilization is expressed explicitly via DECISION events.
+- Boundary and UI clients do not import dbl-core or dbl-policy.
+- The gateway uses dbl-core for canonicalization and digest computation.

dbl_gateway-0.3.2.dist-info/RECORD

@@ -0,0 +1,33 @@
+dbl_gateway/__init__.py,sha256=QjO_Lv-rNZTYa-KPi3CuEb761dTAQ3g_sUOdjAevUIo,19
+dbl_gateway/admission.py,sha256=Ouzb0f-2HFRjaoan0IuXXVXV3SE-TkUbUxIvhv3k4_Q,2568
+dbl_gateway/app.py,sha256=IBXjUXR9A-Jls2TlEWVjeUdCnzstk1dLtvRL_hSXL-s,18435
+dbl_gateway/auth.py,sha256=zdPLt-M8QrdbGgEIQOzNdLhS8M4lE-L_I6mbyKWrA50,9745
+dbl_gateway/capabilities.py,sha256=Pai3TtE5HseTp8dWvQ56ctJzR33rJbL2BUzcGHKFtNk,2340
+dbl_gateway/digest.py,sha256=Qk9qg9cMCLGDWdsvW9tqnjB99YDjC77QwbAM_6_ExxU,1056
+dbl_gateway/execution.py,sha256=y0lCozH2-tCHzfLMOrUg6klv66cLsZnUDKUfSF5jJYk,376
+dbl_gateway/governance.py,sha256=GdHckCHxYfpHrB0F43dvWbztStOCgzNh5wINeYtyFx4,456
+dbl_gateway/models.py,sha256=uZA_JhWOTp1Hfd11XtfQZ_7mLZIsojZxw5GiXBpwjN8,411
+dbl_gateway/projection.py,sha256=GRk0LreZPon0r2wHMom7Uo2-p4mTs5CGcJ27mHoQb2U,1393
+dbl_gateway/wire_contract.py,sha256=qBqqjn-gn851o35Uozm6UXC5cBdF1IdSZ4IHwgAfDoY,2561
+dbl_gateway/adapters/__init__.py,sha256=c4tpiK-xLrOAnULXWFGY46cVXGD4Y9x0Fk34ymVRhwU,253
+dbl_gateway/adapters/execution_adapter_kl.py,sha256=q7JzXliPF83PW-5f3iD2ALR95X-4U9zwLgSYtkGSBC8,4551
+dbl_gateway/adapters/policy_adapter_dbl_policy.py,sha256=yJLZFVZbn7yXKJKeK2m97kcdYNIw_GGACtKv0c7jRUA,3089
+dbl_gateway/adapters/store_adapter_sqlite.py,sha256=KM-rjZrYtvBf0oHExZ6aKfq6wurC3QzkoTTFDv4cIeQ,1228
+dbl_gateway/ports/__init__.py,sha256=cVdnUJacFE-UvHriNfSulJrpMstbhwibdz4n6LMwYMU,261
+dbl_gateway/ports/execution_port.py,sha256=ooHyFS2xoPE1uV9ZT7vj3O3nbM5lffLVrMcN3KcYqj4,498
+dbl_gateway/ports/policy_port.py,sha256=z3zhzw_EOKFaXyDcq4rm02ts6F7hzJsScB_23xI1f_I,436
+dbl_gateway/ports/store_port.py,sha256=UfJMVtAdp4ObPj35EzhP2vZlGtVlx7U3gC5-qMIlcU8,614
+dbl_gateway/providers/__init__.py,sha256=yUmn-w9JEaQ0odrBzC2i9oXYAFRWoHtGt-7m0YlYCsU,44
+dbl_gateway/providers/anthropic.py,sha256=yE3EagKV_wEoXSbVzghrrmt7fwJr-PARxzY384Zz_3s,1765
+dbl_gateway/providers/errors.py,sha256=wF6cQz8Xpc0euwsxDDwo2lZpNzWT5t79-NKQJ3yJNe8,236
+dbl_gateway/providers/openai.py,sha256=a3aPuDWT0jHGtTtkrv1HJKHkmBqiJcwPoLeGjbQRMUo,3231
+dbl_gateway/store/__init__.py,sha256=FlMtW1cV8HO7eqEveaB-YeoUOkXKGGE-AisbQx6uSnQ,40
+dbl_gateway/store/base.py,sha256=R7OzghriIZeCeU5uNG2z2g_gUPpABncSDi9ctDlCk8g,667
+dbl_gateway/store/factory.py,sha256=YkYWKPKfceNxy30SHQxl7MEDsAVyIZFBmRIdeyrB2t8,365
+dbl_gateway/store/sqlite.py,sha256=4j2rYZyGtjfBtoIs25gk9bIncQFtI3r2NgYQcrydcoI,6916
+dbl_gateway-0.3.2.dist-info/licenses/LICENSE,sha256=mEyqjxpmVyq7poufV6nrAhQGN9Qz11eOjrZAyZsH3wc,1070
+dbl_gateway-0.3.2.dist-info/METADATA,sha256=8xs7elrgoGx2o0BE_V3M2cuwQ-5O1-0c2kTvnGu4jSg,2147
+dbl_gateway-0.3.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dbl_gateway-0.3.2.dist-info/entry_points.txt,sha256=Q5_vkct0R-of9dTZX1wfm2cLV5ntFWSzxw78xUb0lNU,53
+dbl_gateway-0.3.2.dist-info/top_level.txt,sha256=FzRFtg710dkEyyNPGCXfRuRDe55_E1ixMxNS4lhD1A4,12
+dbl_gateway-0.3.2.dist-info/RECORD,,

dbl_gateway-0.3.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dbl_gateway-0.3.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dbl-gateway = dbl_gateway.app:main

dbl_gateway-0.3.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Lukas Pfister
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dbl_gateway-0.3.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+dbl_gateway