zambo-haystack 0.1.2__tar.gz → 0.2.0__tar.gz

{zambo_haystack-0.1.2/src/zambo_haystack.egg-info → zambo_haystack-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zambo-haystack
-Version: 0.1.2
+Version: 0.2.0
 Summary: Verifiable execution receipts for Haystack agents. Every tool call mints a verifiable AER-1 receipt at zambo.dev.
 Author-email: Zambo <brennanzambo@zambo.dev>
 License: MIT

{zambo_haystack-0.1.2 → zambo_haystack-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "zambo-haystack"
-version = "0.1.2"
+version = "0.2.0"
 description = "Verifiable execution receipts for Haystack agents. Every tool call mints a verifiable AER-1 receipt at zambo.dev."
 readme = "README.md"
 requires-python = ">=3.10"

zambo_haystack-0.2.0/src/zambo_haystack/__init__.py

@@ -0,0 +1,46 @@
+"""zambo-haystack: Zambo's 100+ live tools as Haystack tools.
+
+Every tool call is executed by live Zambo (https://zambo.dev/api/mcp) and
+mints a verifiable AER-1 execution receipt. No account, no API key, free
+tier: 20 calls per tool per day.
+
+Pass an AER1ReceiptCollector to zambo_tool() to also build a hash-chained
+AER-1 verifiable workflow receipt covering the agent's whole run.
+"""
+
+from .client import call_tool, list_tools, ZamboReceipt, ZamboResult
+from .collector import (
+    AER1ReceiptCollector,
+    DEFAULT_VERIFY_URL,
+    WORKFLOW_TYPE,
+    WORKFLOW_VERSION,
+    merkle_root,
+    verify_workflow_receipt,
+)
+from .tools import (
+    finalize_default_receipt,
+    get_default_collector,
+    lookup_receipt,
+    zambo_tool,
+    zambo_tools,
+)
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "call_tool",
+    "list_tools",
+    "lookup_receipt",
+    "zambo_tool",
+    "zambo_tools",
+    "ZamboReceipt",
+    "ZamboResult",
+    "AER1ReceiptCollector",
+    "get_default_collector",
+    "finalize_default_receipt",
+    "DEFAULT_VERIFY_URL",
+    "WORKFLOW_TYPE",
+    "WORKFLOW_VERSION",
+    "merkle_root",
+    "verify_workflow_receipt",
+]

zambo_haystack-0.2.0/src/zambo_haystack/aer1core.py

@@ -0,0 +1,238 @@
+"""Shared AER-1 workflow-receipt mechanics (stdlib only).
+
+Hash-chained step recording, Section 8.1 Merkle construction, and the
+offline Table 2 / Table 3 verification procedure from draft-zambo-aer1.
+Ported from the aer1-smolagents reference implementation. The collector
+never touches the network and never changes agent behavior. It only
+observes.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import time
+import uuid
+from datetime import datetime, timezone
+
+WORKFLOW_TYPE = "verifiable-workflow-receipt"
+WORKFLOW_VERSION = "1"
+
+# Default verify_url: the canonical home of the AER-1 specification, where
+# the offline verification procedure is documented. Override per deployment.
+DEFAULT_VERIFY_URL = "https://datatracker.ietf.org/doc/draft-zambo-aer1/"
+
+_UUID_RE = re.compile(
+    r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\Z"
+)
+_RFC3339_RE = re.compile(
+    r"^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}"
+    r"(\.[0-9]+)?(Z|[+-][0-9]{2}:[0-9]{2})\Z"
+)
+_HEX64_RE = re.compile(r"^[0-9a-f]{64}\Z")
+
+
+def _new_uuid() -> str:
+    return str(uuid.uuid4())
+
+
+def _rfc3339(ts: float) -> str:
+    """Epoch seconds to a strict RFC 3339 UTC timestamp."""
+    return datetime.fromtimestamp(ts, tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _json_safe(value):
+    """Recursively convert arbitrary values to JSON-serializable form."""
+    if value is None or isinstance(value, (bool, int, float, str)):
+        return value
+    if isinstance(value, dict):
+        return {str(k): _json_safe(v) for k, v in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_json_safe(v) for v in value]
+    if isinstance(value, set):
+        return sorted((_json_safe(v) for v in value), key=repr)
+    return str(value)
+
+
+def _canonical(obj) -> bytes:
+    """Deterministic canonical bytes for hashing (sorted keys, no spaces)."""
+    return json.dumps(
+        _json_safe(obj),
+        sort_keys=True,
+        separators=(",", ":"),
+        ensure_ascii=False,
+    ).encode("utf-8")
+
+
+def _sha256_hex(data: bytes) -> str:
+    return hashlib.sha256(data).hexdigest()
+
+
+def merkle_root(receipt_ids: list) -> str:
+    """AER-1 Section 8.1 normative Merkle construction.
+
+    leaf = SHA-256 over the UTF-8 bytes of receipt_id; internal node =
+    SHA-256 over raw 32-byte left || raw 32-byte right; an odd trailing
+    node is duplicated.
+    """
+    if not receipt_ids:
+        return hashlib.sha256(b"").hexdigest()
+    level = [hashlib.sha256(rid.encode("utf-8")).digest() for rid in receipt_ids]
+    while len(level) > 1:
+        if len(level) % 2:
+            level.append(level[-1])
+        level = [
+            hashlib.sha256(level[i] + level[i + 1]).digest()
+            for i in range(0, len(level), 2)
+        ]
+    return level[0].hex()
+
+
+def _strict_rfc3339(value) -> bool:
+    """Strict RFC 3339 check: shape, offset range, and real calendar date."""
+    if not isinstance(value, str) or not _RFC3339_RE.match(value):
+        return False
+    if not value.endswith("Z"):
+        off = value[-6:]
+        try:
+            oh, om = int(off[1:3]), int(off[4:6])
+        except ValueError:
+            return False
+        if not (0 <= oh <= 23 and 0 <= om <= 59):
+            return False
+    try:
+        datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError:
+        return False
+    return True
+
+
+def verify_workflow_receipt(workflow) -> list:
+    """Offline AER-1 Section 8 verification of a workflow receipt.
+
+    Returns a list of failure reasons; an empty list means the receipt is
+    valid. Mirrors the Table 2 / Table 3 MUST checks of the AER-1
+    conformance kit: workflow members, step members, seq ordering 1..n,
+    no duplicate step receipt_id values (MM-1), and the Section 8.1
+    Merkle root recomputed over the ordered step receipt_id strings.
+    """
+    failures = []
+    if not isinstance(workflow, dict):
+        return ["workflow is not a JSON object"]
+    if workflow.get("type") != WORKFLOW_TYPE:
+        failures.append('workflow type is not "verifiable-workflow-receipt"')
+    version = workflow.get("version")
+    if not isinstance(version, str) or not version:
+        failures.append("workflow version is not a non-empty string")
+    if not isinstance(workflow.get("workflow_id"), str) or not _UUID_RE.match(
+        workflow.get("workflow_id")
+    ):
+        failures.append("workflow workflow_id is not a lowercase UUID")
+    if not isinstance(workflow.get("receipt_id"), str) or not _UUID_RE.match(
+        workflow.get("receipt_id")
+    ):
+        failures.append("workflow receipt_id is not a lowercase UUID")
+    if not isinstance(workflow.get("session_id"), str) or not workflow.get("session_id"):
+        failures.append("workflow session_id is not a non-empty string")
+    if not isinstance(workflow.get("goal"), str) or not workflow.get("goal"):
+        failures.append("workflow goal is not a non-empty string")
+    if not isinstance(workflow.get("status"), str) or not workflow.get("status"):
+        failures.append("workflow status is not a non-empty string")
+    oh = workflow.get("output_hash")
+    if not isinstance(oh, str) or not _HEX64_RE.match(oh):
+        failures.append("workflow output_hash is not a 64-char lowercase hex digest")
+    vu = workflow.get("verify_url")
+    if not isinstance(vu, str) or not (
+        vu.startswith("http://") or vu.startswith("https://")
+    ):
+        failures.append("workflow verify_url is not an http(s) URL string")
+    steps = workflow.get("steps")
+    if not isinstance(steps, list) or not steps:
+        failures.append("workflow steps is not a non-empty list")
+        return failures
+    for i, step in enumerate(steps):
+        if not isinstance(step, dict):
+            failures.append(f"step {i + 1} is not an object")
+            continue
+        seq = step.get("seq")
+        if isinstance(seq, bool) or not (
+            isinstance(seq, int) or (isinstance(seq, float) and seq.is_integer())
+        ):
+            failures.append(f"step {i + 1} seq is not an integer")
+        if not isinstance(step.get("receipt_id"), str):
+            failures.append(f"step {i + 1} receipt_id is not a string")
+        if not isinstance(step.get("tool"), str) or not step.get("tool"):
+            failures.append(f"step {i + 1} tool is not a non-empty string")
+        rh = step.get("receipt_hash")
+        if not isinstance(rh, str) or not _HEX64_RE.match(rh):
+            failures.append(
+                f"step {i + 1} receipt_hash is not a 64-char lowercase hex digest"
+            )
+        if not _strict_rfc3339(step.get("started_at")):
+            failures.append(f"step {i + 1} started_at is not a valid RFC 3339 timestamp")
+        if not _strict_rfc3339(step.get("ended_at")):
+            failures.append(f"step {i + 1} ended_at is not a valid RFC 3339 timestamp")
+        if not isinstance(step.get("status"), str) or not step.get("status"):
+            failures.append(f"step {i + 1} status is not a non-empty string")
+    if failures:
+        return failures
+    n = len(steps)
+    for i, step in enumerate(steps):
+        if step["seq"] != i + 1:
+            failures.append(
+                f"step seq values are not 1..{n} in order "
+                f"(index {i} carries seq {step['seq']})"
+            )
+            break
+    seen = set()
+    for step in steps:
+        rid = step["receipt_id"]
+        if rid in seen:
+            failures.append(f"duplicate receipt_id: {rid}")
+            break
+        seen.add(rid)
+    root = merkle_root([step["receipt_id"] for step in steps])
+    mr = workflow.get("merkle_root")
+    if not isinstance(mr, str) or mr != root:
+        failures.append("merkle_root does not match the recomputed Section 8.1 root")
+    return failures
+
+
+def record_step(tool, content, started_at=None, ended_at=None, status="ok", seq=0):
+    """Build one hash-chained workflow step record.
+
+    receipt_hash commits to the canonical JSON of the step content
+    (tool name, arguments, observations, output, error), so the hash
+    proves what the agent actually did.
+    """
+    start = started_at if started_at is not None else time.time()
+    end = ended_at if ended_at is not None and ended_at >= start else start
+    return {
+        "seq": seq,
+        "receipt_id": _new_uuid(),
+        "tool": tool,
+        "receipt_hash": _sha256_hex(_canonical(content)),
+        "started_at": _rfc3339(start),
+        "ended_at": _rfc3339(end),
+        "status": status,
+    }
+
+
+def assemble_workflow(steps, goal, session_id, verify_url, final_answer=None):
+    """Assemble the AER-1 verifiable workflow receipt for observed steps."""
+    status = "error" if any(s["status"] == "error" for s in steps) else "ok"
+    answer_text = "" if final_answer is None else str(final_answer)
+    return {
+        "type": WORKFLOW_TYPE,
+        "version": WORKFLOW_VERSION,
+        "workflow_id": _new_uuid(),
+        "receipt_id": _new_uuid(),
+        "session_id": session_id,
+        "goal": goal,
+        "status": status,
+        "steps": list(steps),
+        "merkle_root": merkle_root([s["receipt_id"] for s in steps]),
+        "output_hash": _sha256_hex(answer_text.encode("utf-8")),
+        "verify_url": verify_url,
+    }

zambo_haystack-0.2.0/src/zambo_haystack/collector.py

@@ -0,0 +1,202 @@
+"""AER-1 verifiable workflow receipts for Haystack.
+
+AER1ReceiptCollector observes Haystack tool executions and builds a
+hash-chained AER-1 verifiable workflow receipt (draft-zambo-aer1,
+Section 8) covering the whole run. verify() re-checks the receipt with
+the same offline mechanics as the AER-1 conformance kit.
+
+Native integration: pass ``collector=collector`` to ``zambo_tool()`` /
+``zambo_tools()`` and every invocation of the built Haystack Tool is
+recorded as a workflow step::
+
+    from zambo_haystack import zambo_tool, AER1ReceiptCollector
+
+    collector = AER1ReceiptCollector(goal="Check the price")
+    tool = zambo_tool("live_price", collector=collector)
+    # add the tool to your Haystack pipeline or agent as usual
+    receipt = collector.finalize()
+    assert collector.verify(receipt) == []
+
+A module-level default collector is also available: omit ``collector``
+and steps go to ``get_default_collector()``; call
+``finalize_default_receipt()`` to emit its receipt.
+
+The collector never touches the network and never changes agent behavior.
+It only observes."""
+
+from __future__ import annotations
+
+import functools
+import inspect
+import json
+import time
+
+from .aer1core import (
+    DEFAULT_VERIFY_URL,
+    WORKFLOW_TYPE,
+    WORKFLOW_VERSION,
+    _json_safe,
+    _new_uuid,
+    assemble_workflow,
+    merkle_root,
+    record_step,
+    verify_workflow_receipt,
+)
+
+__all__ = [
+    "AER1ReceiptCollector",
+    "DEFAULT_VERIFY_URL",
+    "WORKFLOW_TYPE",
+    "WORKFLOW_VERSION",
+    "merkle_root",
+    "verify_workflow_receipt",
+]
+
+
+class AER1ReceiptCollector:
+    """Haystack tool observer that builds AER-1 verifiable workflow receipts."""
+
+    def __init__(self, goal=None, session_id=None, verify_url=None):
+        self._goal = goal
+        self._session_id = session_id or _new_uuid()
+        self._verify_url = verify_url or DEFAULT_VERIFY_URL
+        self._steps = []
+        self._seq = 0
+
+    # -- step recording ------------------------------------------------------
+    def record_tool_call(
+        self,
+        tool,
+        arguments=None,
+        output=None,
+        error=None,
+        started_at=None,
+        ended_at=None,
+    ):
+        """Record one observed tool call as a hash-chained workflow step."""
+        self._seq += 1
+        content = {
+            "tool": tool,
+            "arguments": _json_safe(arguments),
+            "output": _json_safe(output),
+            "error": str(error) if error is not None else None,
+        }
+        step = record_step(
+            tool=str(tool),
+            content=content,
+            started_at=started_at,
+            ended_at=ended_at,
+            status="error" if error is not None else "ok",
+            seq=self._seq,
+        )
+        self._steps.append(step)
+        return step
+
+    # -- native PydanticAI integration: the observe decorator ------------------
+    def observe(self, fn=None, *, name=None):
+        """Decorate a tool function so every call is recorded as a step.
+
+        Works with sync and async functions. The wrapped function keeps its
+        name, signature, and docstring, so PydanticAI registers it exactly
+        as before; the only addition is the recorded step.
+        """
+        def decorator(func):
+            tool_name = name or getattr(func, "__name__", "tool")
+
+            if inspect.iscoroutinefunction(func):
+
+                @functools.wraps(func)
+                async def async_wrapper(*args, **kwargs):
+                    started = time.time()
+                    try:
+                        result = await func(*args, **kwargs)
+                    except Exception as exc:
+                        self.record_tool_call(
+                            tool_name,
+                            arguments={"args": args, "kwargs": kwargs},
+                            error=exc,
+                            started_at=started,
+                        )
+                        raise
+                    self.record_tool_call(
+                        tool_name,
+                        arguments={"args": args, "kwargs": kwargs},
+                        output=result,
+                        started_at=started,
+                    )
+                    return result
+
+                return async_wrapper
+
+            @functools.wraps(func)
+            def sync_wrapper(*args, **kwargs):
+                started = time.time()
+                try:
+                    result = func(*args, **kwargs)
+                except Exception as exc:
+                    self.record_tool_call(
+                        tool_name,
+                        arguments={"args": args, "kwargs": kwargs},
+                        error=exc,
+                        started_at=started,
+                    )
+                    raise
+                self.record_tool_call(
+                    tool_name,
+                    arguments={"args": args, "kwargs": kwargs},
+                    output=result,
+                    started_at=started,
+                )
+                return result
+
+            return sync_wrapper
+
+        return decorator(fn) if fn is not None else decorator
+
+    # -- receipt assembly ------------------------------------------------------
+    def finalize(self, final_answer=None) -> dict:
+        """Emit the AER-1 verifiable workflow receipt for the observed run."""
+        goal = self._goal or "haystack run"
+        return assemble_workflow(
+            steps=self._steps,
+            goal=goal,
+            session_id=self._session_id,
+            verify_url=self._verify_url,
+            final_answer=final_answer,
+        )
+
+    def verify(self, workflow=None) -> list:
+        """Offline-verify a workflow receipt. [] means valid.
+
+        With no argument, finalizes the current run and verifies that
+        receipt. Pass an explicit receipt dict to verify that exact
+        object (for example, one loaded from disk).
+        """
+        if workflow is None:
+            workflow = self.finalize()
+        return verify_workflow_receipt(workflow)
+
+    def to_json(self, workflow=None, indent=2) -> str:
+        """Serialize a workflow receipt to JSON text."""
+        if workflow is None:
+            workflow = self.finalize()
+        return json.dumps(workflow, indent=indent, ensure_ascii=False)
+
+    def save(self, path, workflow=None) -> str:
+        """Write a workflow receipt to path as JSON. Returns the path."""
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(self.to_json(workflow))
+        return path
+
+    def reset(self):
+        """Clear recorded steps so the collector can observe a fresh run."""
+        self._steps = []
+        self._seq = 0
+
+    @property
+    def step_count(self) -> int:
+        return len(self._steps)
+
+    @property
+    def session_id(self) -> str:
+        return self._session_id

{zambo_haystack-0.1.2 → zambo_haystack-0.2.0}/src/zambo_haystack/tools.py

@@ -16,6 +16,24 @@ from typing import Any, Callable
 from haystack.tools import Tool
 
 from . import client as _client
+from .collector import AER1ReceiptCollector
+
+# Module-level default collector: when zambo_tool() is called without an
+# explicit collector, invocations are recorded here. Observation only.
+_default_collector: AER1ReceiptCollector | None = None
+
+
+def get_default_collector() -> AER1ReceiptCollector:
+    """Return the module-level default AER-1 collector, creating it on demand."""
+    global _default_collector
+    if _default_collector is None:
+        _default_collector = AER1ReceiptCollector(goal="haystack run")
+    return _default_collector
+
+
+def finalize_default_receipt(final_answer=None) -> dict:
+    """Emit the AER-1 workflow receipt for the default collector's steps."""
+    return get_default_collector().finalize(final_answer=final_answer)
 
 # (tool_name, arguments_json) -> (receipt_url, finished_at). Written by the
 # tool wrapper on every invocation. Thread-safe. Query it with
@@ -41,6 +59,7 @@ def zambo_tool(
     description: str | None = None,
     params_json_schema: dict | None = None,
     on_receipt: Callable[[str, str], Any] | None = None,
+    collector: AER1ReceiptCollector | None = None,
 ) -> Tool:
     """Build a Haystack Tool backed by a Zambo MCP tool.
 
@@ -52,15 +71,28 @@ def zambo_tool(
             Defaults to a permissive object schema; Zambo validates server-side.
         on_receipt: Optional callback invoked as on_receipt(tool_name,
             receipt_url) after every successful invocation.
+        collector: Optional AER1ReceiptCollector. Every invocation is recorded
+            as a hash-chained workflow step (observation only; the tool's
+            behavior is unchanged). When omitted, the module-level default
+            collector is used (see get_default_collector()).
 
     The tool's result text ends with a "Verifiable receipt: <url>" line, and
     the URL is also recorded in the invocation registry (see
     lookup_receipt()).
     """
     schema = params_json_schema or {"type": "object", "properties": {}}
+    step_collector = collector if collector is not None else get_default_collector()
 
     def _run(**kwargs: Any) -> str:
-        result = _client.call_tool(tool_name, dict(kwargs))
+        arguments = dict(kwargs)
+        started = time.time()
+        try:
+            result = _client.call_tool(tool_name, arguments)
+        except Exception as exc:
+            step_collector.record_tool_call(
+                tool_name, arguments=arguments, error=exc, started_at=started
+            )
+            raise
 
         receipt_url = result.receipt.url if result.receipt else ""
         arguments_json = json.dumps(kwargs, sort_keys=True)
@@ -69,6 +101,13 @@ def zambo_tool(
             if on_receipt is not None:
                 on_receipt(tool_name, receipt_url)
 
+        step_collector.record_tool_call(
+            tool_name,
+            arguments=arguments,
+            output={"text": result.text[:2000], "receipt_url": receipt_url},
+            started_at=started,
+        )
+
         output = result.text or "(empty result)"
         if receipt_url:
             output += f"\n\nVerifiable receipt: {receipt_url}"

{zambo_haystack-0.1.2 → zambo_haystack-0.2.0/src/zambo_haystack.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zambo-haystack
-Version: 0.1.2
+Version: 0.2.0
 Summary: Verifiable execution receipts for Haystack agents. Every tool call mints a verifiable AER-1 receipt at zambo.dev.
 Author-email: Zambo <brennanzambo@zambo.dev>
 License: MIT

{zambo_haystack-0.1.2 → zambo_haystack-0.2.0}/src/zambo_haystack.egg-info/SOURCES.txt

@@ -2,10 +2,13 @@ LICENSE
 README.md
 pyproject.toml
 src/zambo_haystack/__init__.py
+src/zambo_haystack/aer1core.py
 src/zambo_haystack/client.py
+src/zambo_haystack/collector.py
 src/zambo_haystack/tools.py
 src/zambo_haystack.egg-info/PKG-INFO
 src/zambo_haystack.egg-info/SOURCES.txt
 src/zambo_haystack.egg-info/dependency_links.txt
 src/zambo_haystack.egg-info/requires.txt
-src/zambo_haystack.egg-info/top_level.txt
+src/zambo_haystack.egg-info/top_level.txt
+tests/test_aer1_collector.py

zambo_haystack-0.2.0/tests/test_aer1_collector.py

@@ -0,0 +1,112 @@
+"""Tests for the zambo-haystack 0.2.0 AER-1 collector.
+
+The collector and aer1core are stdlib-only; no haystack-ai install needed.
+Tool-wiring is tested without network by exercising the record path.
+"""
+
+import copy
+import importlib.util
+import os
+import sys
+import types
+
+
+def _load(name, relpath):
+    base = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "src",
+                        "zambo_haystack")
+    # Stub the parent package (without executing its __init__, which needs
+    # haystack-ai) so the collector's relative import resolves.
+    if "zambo_haystack" not in sys.modules:
+        pkg = types.ModuleType("zambo_haystack")
+        pkg.__path__ = [base]
+        sys.modules["zambo_haystack"] = pkg
+    path = os.path.join(base, relpath)
+    spec = importlib.util.spec_from_file_location(name, path)
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules[name] = mod
+    spec.loader.exec_module(mod)
+    return mod
+
+
+aer1core = _load("zambo_haystack.aer1core", "aer1core.py")
+collector_mod = _load("zambo_haystack.collector", "collector.py")
+
+merkle_root = aer1core.merkle_root
+AER1ReceiptCollector = collector_mod.AER1ReceiptCollector
+WORKFLOW_TYPE = collector_mod.WORKFLOW_TYPE
+verify_workflow_receipt = collector_mod.verify_workflow_receipt
+
+
+def make_collector():
+    return AER1ReceiptCollector(goal="test run")
+
+
+def test_synthetic_steps_verify():
+    c = make_collector()
+    c.record_tool_call("live_price", arguments={"symbol": "BTC"}, output="$1")
+    c.record_tool_call("web_search", arguments={"q": "x"}, output="r")
+    receipt = c.finalize(final_answer="done")
+    assert verify_workflow_receipt(receipt) == []
+    assert receipt["type"] == WORKFLOW_TYPE
+    assert [s["seq"] for s in receipt["steps"]] == [1, 2]
+
+
+def test_empty_run_does_not_verify():
+    c = make_collector()
+    failures = verify_workflow_receipt(c.finalize(final_answer="x"))
+    assert failures and any("steps" in f for f in failures)
+
+
+def test_tampered_tool_fails():
+    c = make_collector()
+    c.record_tool_call("a", output="1")
+    receipt = c.finalize(final_answer="1")
+    assert c.verify(receipt) == []
+    bad = copy.deepcopy(receipt)
+    bad["steps"][0]["tool"] = ""
+    assert c.verify(bad) != []
+
+
+def test_tampered_merkle_root_fails():
+    c = make_collector()
+    c.record_tool_call("a", output="1")
+    receipt = c.finalize(final_answer="1")
+    bad = copy.deepcopy(receipt)
+    bad["merkle_root"] = "0" * 64
+    assert any("merkle_root" in f for f in c.verify(bad))
+
+
+def test_duplicate_receipt_id_fails():
+    c = make_collector()
+    c.record_tool_call("a", output="1")
+    c.record_tool_call("b", output="2")
+    receipt = c.finalize(final_answer="x")
+    bad = copy.deepcopy(receipt)
+    bad["steps"][1]["receipt_id"] = bad["steps"][0]["receipt_id"]
+    assert any("duplicate" in f for f in c.verify(bad))
+
+
+def test_error_step_marks_workflow_error():
+    c = make_collector()
+    c.record_tool_call("broken", error=RuntimeError("boom"))
+    receipt = c.finalize()
+    assert receipt["status"] == "error"
+    assert verify_workflow_receipt(receipt) == []
+
+
+def test_observe_decorator():
+    c = make_collector()
+
+    @c.observe(name="pipeline_step")
+    def run_component(x):
+        return x * 2
+
+    assert run_component(21) == 42
+    assert c.step_count == 1
+    assert c.verify() == []
+
+
+def test_merkle_reference_vector():
+    assert merkle_root([]) == (
+        "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    )

zambo_haystack-0.1.2/src/zambo_haystack/__init__.py

@@ -1,21 +0,0 @@
-"""zambo-haystack: Zambo's 100+ live tools as Haystack tools.
-
-Every tool call is executed by live Zambo (https://zambo.dev/api/mcp) and
-mints a verifiable AER-1 execution receipt. No account, no API key, free
-tier: 20 calls per tool per day.
-"""
-
-from .client import call_tool, list_tools, ZamboReceipt, ZamboResult
-from .tools import lookup_receipt, zambo_tool, zambo_tools
-
-__version__ = "0.1.0"
-
-__all__ = [
-    "call_tool",
-    "list_tools",
-    "lookup_receipt",
-    "zambo_tool",
-    "zambo_tools",
-    "ZamboReceipt",
-    "ZamboResult",
-]