openwright-langfuse 0.3.0__tar.gz

openwright_langfuse-0.3.0/.gitignore

@@ -0,0 +1,20 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
+.venv/
+venv/
+dist/
+build/
+
+# generated evidence / demo artifacts
+*.pem
+*.pem.pub
+openwright-out/
+*-ledger/
+out/
+
+# node / OS
+node_modules/
+.DS_Store

openwright_langfuse-0.3.0/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: openwright-langfuse
+Version: 0.3.0
+Summary: Langfuse forwarder for OpenWright — co-ingest + openwright:* verdict back-link + evals-as-evidence.
+License: Apache-2.0
+Keywords: evidence,forwarder,langfuse,observability,openwright
+Requires-Python: <3.15,>=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: openwright-core<0.7,>=0.6
+Provides-Extra: test
+Requires-Dist: openwright-conformance; extra == 'test'
+Requires-Dist: pytest>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+# openwright-langfuse
+
+A **Langfuse forwarder** for [OpenWright](https://github.com/allthingsN/openwright):
+keep your traces in Langfuse *and* attach the OpenWright verdicts back to them.
+
+- **forward** — co-ingest a telemetry batch to Langfuse unchanged (Basic auth +
+  `x-langfuse-ingestion-version: 4`).
+- **backlink** — push `openwright:<control>` scores (the verdicts) onto the trace,
+  with the reason as a comment; returns a deep-link.
+- **pull** — read Langfuse scores/evals back as `ComplianceEvent`s (evals-as-evidence).
+
+```python
+from openwright.connectors import load
+fwd = load("openwright.forwarders", "langfuse")
+cfg = {"host": "https://cloud.langfuse.com", "public_key": "pk-…", "secret_key": "sk-…", "trace_id": trace_id}
+fwd.backlink(report, config=cfg)   # openwright:* verdicts now on the Langfuse trace
+```
+
+No partnership or endorsement implied; built on Langfuse's public HTTP API. No
+crypto is reimplemented here.

openwright_langfuse-0.3.0/README.md

@@ -0,0 +1,20 @@
+# openwright-langfuse
+
+A **Langfuse forwarder** for [OpenWright](https://github.com/allthingsN/openwright):
+keep your traces in Langfuse *and* attach the OpenWright verdicts back to them.
+
+- **forward** — co-ingest a telemetry batch to Langfuse unchanged (Basic auth +
+  `x-langfuse-ingestion-version: 4`).
+- **backlink** — push `openwright:<control>` scores (the verdicts) onto the trace,
+  with the reason as a comment; returns a deep-link.
+- **pull** — read Langfuse scores/evals back as `ComplianceEvent`s (evals-as-evidence).
+
+```python
+from openwright.connectors import load
+fwd = load("openwright.forwarders", "langfuse")
+cfg = {"host": "https://cloud.langfuse.com", "public_key": "pk-…", "secret_key": "sk-…", "trace_id": trace_id}
+fwd.backlink(report, config=cfg)   # openwright:* verdicts now on the Langfuse trace
+```
+
+No partnership or endorsement implied; built on Langfuse's public HTTP API. No
+crypto is reimplemented here.

openwright_langfuse-0.3.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "openwright-langfuse"
+version = "0.3.0"
+description = "Langfuse forwarder for OpenWright — co-ingest + openwright:* verdict back-link + evals-as-evidence."
+requires-python = ">=3.10,<3.15"
+license = { text = "Apache-2.0" }
+readme = "README.md"
+keywords = ["openwright", "langfuse", "observability", "forwarder", "evidence"]
+dependencies = ["openwright-core>=0.6,<0.7", "httpx>=0.27"]
+
+[project.optional-dependencies]
+test = ["pytest>=8", "openwright-conformance"]
+
+[project.entry-points."openwright.forwarders"]
+langfuse = "openwright_langfuse:forwarder"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/openwright_langfuse"]

openwright_langfuse-0.3.0/src/openwright_langfuse/__init__.py

@@ -0,0 +1,98 @@
+"""Langfuse forwarder for OpenWright (CONN-2).
+
+The downstream-observability pattern as a :class:`Forwarder`:
+
+* ``forward``  — co-ingest a telemetry batch to Langfuse **unchanged**, injecting
+  Basic auth + ``x-langfuse-ingestion-version: 4`` (Langfuse is HTTP-only).
+* ``backlink`` — push ``openwright:<control>`` **scores** (the verdicts) onto the
+  Langfuse trace via the public API, with the reason as a comment, and return a
+  deep-link to the trace.
+* ``pull``     — read Langfuse scores/evals and yield them as ``ComplianceEvent``s
+  (evals-as-evidence).
+
+No crypto here; payloads are hashed by the source connector before they become
+events. ``config`` carries ``host``, ``public_key``, ``secret_key`` and per-call
+fields (``trace_id`` for ``backlink``). Pass ``_transport`` (an httpx transport)
+to talk to a stub in tests.
+"""
+
+from __future__ import annotations
+
+import base64
+from typing import Any, Iterable
+
+from openwright.connectors import CONTRACT_VERSION, ExportResult
+
+__all__ = ["LangfuseForwarder", "forwarder", "CONTRACT_VERSION"]
+
+
+class LangfuseForwarder:
+    name = "langfuse"
+    CONTRACT_VERSION = CONTRACT_VERSION
+
+    def _client(self, config: dict):
+        import httpx
+
+        host = str(config["host"]).rstrip("/")
+        token = base64.b64encode(
+            f"{config['public_key']}:{config['secret_key']}".encode("utf-8")
+        ).decode("ascii")
+        headers = {
+            "Authorization": f"Basic {token}",
+            "x-langfuse-ingestion-version": "4",
+        }
+        return httpx.Client(
+            base_url=host, headers=headers, timeout=config.get("timeout", 10),
+            transport=config.get("_transport"),
+        )
+
+    def forward(self, payload: Any, *, config: dict) -> ExportResult:
+        path = config.get("ingest_path", "/api/public/otel/v1/traces")
+        with self._client(config) as c:
+            if isinstance(payload, (bytes, bytearray)):
+                r = c.post(path, content=bytes(payload),
+                           headers={"Content-Type": "application/x-protobuf"})
+            else:
+                r = c.post(path, json=payload)
+        return ExportResult(ok=r.is_success, detail=f"forward -> HTTP {r.status_code}")
+
+    def backlink(self, report: dict, *, config: dict) -> ExportResult:
+        trace_id = config.get("trace_id")
+        oks: list[bool] = []
+        with self._client(config) as c:
+            for ctrl in report.get("controls", []):
+                body = {
+                    "traceId": trace_id,
+                    "name": f"openwright:{ctrl['control_id']}",
+                    "value": ctrl["status"],
+                    "dataType": "CATEGORICAL",
+                    "comment": (ctrl.get("reason") or "")[:500],
+                }
+                oks.append(c.post("/api/public/scores", json=body).is_success)
+        url = f"{str(config['host']).rstrip('/')}/trace/{trace_id}" if trace_id else None
+        ok = all(oks) if oks else True
+        return ExportResult(ok=ok, detail=f"back-linked {sum(oks)}/{len(oks)} verdict(s)", url=url)
+
+    def pull(self, *, config: dict) -> Iterable[Any]:
+        from openwright.canonical import to_rfc3339
+        from openwright.events import ComplianceEvent, EventKind
+
+        with self._client(config) as c:
+            r = c.get("/api/public/scores", params={"limit": config.get("limit", 50)})
+            r.raise_for_status()
+            for sc in r.json().get("data", []):
+                yield ComplianceEvent(
+                    timestamp=to_rfc3339(sc.get("timestamp") or "1970-01-01T00:00:00.000000000Z"),
+                    kind=EventKind.CONFORMANCE_FINDING,
+                    actor={"agent_id": "langfuse"},
+                    source={"format": "langfuse"},
+                    attributes={
+                        "score_name": sc.get("name"),
+                        "value": str(sc.get("value")),
+                        "trace_id": sc.get("traceId"),
+                    },
+                )
+
+
+#: The object the ``openwright.forwarders:langfuse`` entry point loads to.
+forwarder = LangfuseForwarder()

openwright_langfuse-0.3.0/tests/test_langfuse.py

@@ -0,0 +1,67 @@
+"""Conformance + request-shape behavior (httpx mock transport) for openwright-langfuse."""
+
+from __future__ import annotations
+
+import base64
+import json
+
+import httpx
+
+from openwright_conformance import run_conformance
+from openwright_langfuse import forwarder
+
+CONFIG = {"host": "https://cloud.langfuse.test", "public_key": "pk", "secret_key": "sk"}
+
+
+def test_conforms():
+    run_conformance(forwarder, group="openwright.forwarders", name="langfuse", modules=["openwright_langfuse"])
+
+
+def test_forward_injects_auth_and_ingestion_version():
+    seen = {}
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen["url"] = str(request.url)
+        seen["auth"] = request.headers.get("Authorization")
+        seen["iv"] = request.headers.get("x-langfuse-ingestion-version")
+        return httpx.Response(207)
+
+    cfg = {**CONFIG, "_transport": httpx.MockTransport(handler)}
+    res = forwarder.forward(b"\x00otlp-bytes", config=cfg)
+    assert res.ok
+    assert seen["url"].endswith("/api/public/otel/v1/traces")
+    assert seen["auth"] == "Basic " + base64.b64encode(b"pk:sk").decode()
+    assert seen["iv"] == "4"
+
+
+def test_backlink_posts_openwright_verdict_scores():
+    posted = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        assert request.url.path == "/api/public/scores"
+        posted.append(json.loads(request.content))
+        return httpx.Response(201)
+
+    cfg = {**CONFIG, "trace_id": "tr_123", "_transport": httpx.MockTransport(handler)}
+    report = {"controls": [
+        {"control_id": "art-14-human-oversight", "status": "satisfied", "reason": "approved"},
+        {"control_id": "art-27-fria", "status": "not_satisfied", "reason": "no FRIA"},
+    ]}
+    res = forwarder.backlink(report, config=cfg)
+    assert res.ok and res.url == "https://cloud.langfuse.test/trace/tr_123"
+    names = {p["name"]: p["value"] for p in posted}
+    assert names == {"openwright:art-14-human-oversight": "satisfied", "openwright:art-27-fria": "not_satisfied"}
+    assert all(p["traceId"] == "tr_123" for p in posted)
+
+
+def test_pull_yields_events_from_scores():
+    def handler(request: httpx.Request) -> httpx.Response:
+        return httpx.Response(200, json={"data": [
+            {"name": "hallucination", "value": 0.1, "traceId": "tr_1", "timestamp": "2026-05-28T00:00:00Z"},
+        ]})
+
+    cfg = {**CONFIG, "_transport": httpx.MockTransport(handler)}
+    events = list(forwarder.pull(config=cfg))
+    assert len(events) == 1
+    assert events[0].kind == "conformance_finding"
+    assert events[0].attributes["score_name"] == "hallucination"