langchain-sealkeeper 0.1.0__tar.gz

langchain_sealkeeper-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+.venv/
+__pycache__/
+.pytest_cache/
+.ruff_cache/
+dist/
+uv.lock

langchain_sealkeeper-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 The SealKeeper Authors
+
+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.

langchain_sealkeeper-0.1.0/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.5
+Name: langchain-sealkeeper
+Version: 0.1.0
+Summary: LangChain tools and gates that check a SealKeeper SEAL before an agent calls an agent or an MCP server.
+Project-URL: Homepage, https://sealkeeper.run
+Project-URL: SEAL Standard, https://sealkeeper.run/seal/standard
+Project-URL: Repository, https://github.com/sealkeeper-dev/langchain-sealkeeper
+Project-URL: Issues, https://github.com/sealkeeper-dev/langchain-sealkeeper/issues
+Author: The SealKeeper Authors
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: langchain-core<2,>=1.7.3
+Requires-Dist: langchain<2,>=1.4.7
+Requires-Dist: sealkeeper<0.2,>=0.1.0
+Description-Content-Type: text/markdown
+
+# langchain-sealkeeper
+
+Check an AI agent or MCP server on [SealKeeper](https://sealkeeper.run) from LangChain, before your agent calls it.
+
+A SEAL is SealKeeper's signed credential for an agent or a service. This package wires the [`sealkeeper`](https://pypi.org/project/sealkeeper/) library into LangChain. Every SEAL is verified on your machine and every decision is the library's `Gate`.
+
+## Install
+
+```sh
+pip install langchain-sealkeeper
+```
+
+Python 3.10 or later. It depends on `sealkeeper`, `langchain-core` and `langchain`.
+
+## Look up
+
+`SealKeeperLookupTool` lets the model look a target up.
+
+```python
+from langchain.agents import create_agent
+from langchain_sealkeeper import SealKeeperLookupTool
+
+agent = create_agent(model, tools=[SealKeeperLookupTool()])
+```
+
+The tool is `sealkeeper_lookup`, with one argument, `target`. A target is a handle such as `alice/helper`, a SealKeeper page URL, an agent id, a `did:key`, an A2A card URL or an MCP server URL.
+
+The model reads one line, such as `alice/helper: verified agent SEAL, level bronze, Trust Score 412.` or `alice/helper: no verified SEAL (broken, bad_signature).`
+
+The `ToolMessage` artifact is the lookup as a dict of JSON values, so a checkpointer keeps it as it is. `verified` says whether the SEAL verified, and `seal` holds it when it did. Without one, `code` says why, as in the `sealkeeper` library's `Lookup`. A broken SEAL reads `verified` false and no level, kind or Trust Score.
+
+A lookup that fails, such as SealKeeper not answering in time, answers an error `ToolMessage` with the reason.
+
+## Gate an MCP server
+
+`SealGateInterceptor` checks an MCP server's SEAL before each call to one of its tools. It needs `langchain-mcp-adapters`.
+
+```python
+from langchain_mcp_adapters.client import MultiServerMCPClient
+from langchain_sealkeeper import SealGateInterceptor
+
+connections = {
+    "weather": {"transport": "streamable_http", "url": "https://mcp.example.com/mcp"},
+    "notes": {"transport": "stdio", "command": "notes-server", "args": []},
+}
+gate = SealGateInterceptor(connections, ["weather"])
+client = MultiServerMCPClient(connections, tool_interceptors=[gate])
+tools = await client.get_tools()
+```
+
+Pass it the same `connections` as the client. It reads each server's `url` from them at every call, as a service. Load the tools with `client.get_tools()`, or with `load_mcp_tools(session, server_name=...)` and the connection's name, since a tool loaded without its server's name is not gated.
+
+- A pass calls the tool.
+- A block answers an error `ToolMessage` with the code and the reason, such as `SealKeeper blocked this call: not_found. SealKeeper knows no agent or service by that target`. The tool is not called and the agent's run goes on. The message has no `name`, and outside a LangGraph `ToolNode` its `tool_call_id` is empty.
+- A server you do not name passes untouched.
+- A stdio server has no URL to check, so naming one raises `ValueError`.
+
+## Gate a remote agent
+
+`SealGateMiddleware` checks a target's SEAL before each call to a tool that calls it, such as a tool that sends a task to a remote A2A agent.
+
+```python
+from langchain.agents import create_agent
+from langchain_sealkeeper import SealGateMiddleware, SealTarget
+
+gate = SealGateMiddleware({
+    "ask_helper": SealTarget("agent", "alice/helper"),
+    "fetch_report": SealTarget("service", "https://mcp.example.com/mcp"),
+})
+agent = create_agent(model, tools=[ask_helper, fetch_report, search], middleware=[gate])
+```
+
+Each pinned tool name maps to a `SealTarget(kind, ref)`. `kind` is `"agent"` or `"service"`, and `ref` is any target the lookup takes. A block answers an error `ToolMessage` with the code and the reason, the tool is not called and the run goes on. A tool you do not pin passes untouched. It works with `invoke` and `ainvoke`.
+
+## The rules
+
+Both gates decide with a `sealkeeper.Gate` and its default rules. A pass needs a current, valid SEAL of the kind at bronze or above, and for a card or MCP server URL the SEAL must name that URL.
+
+`allow_unsealed=True` on either gate also lets through a target SealKeeper does not know, one it is still checking and one with no SEAL while it is dormant. A withheld or broken SEAL, a delisted target and SealKeeper unavailable still block.
+
+```python
+gate = SealGateInterceptor(connections, ["weather"], allow_unsealed=True)
+```
+
+The block codes are in the [`sealkeeper` README](https://pypi.org/project/sealkeeper/). Each decision writes one INFO line to the `sealkeeper` logger, never the SEAL, a full URL or the tool's arguments.
+
+## License
+
+MIT

langchain_sealkeeper-0.1.0/README.md

@@ -0,0 +1,89 @@
+# langchain-sealkeeper
+
+Check an AI agent or MCP server on [SealKeeper](https://sealkeeper.run) from LangChain, before your agent calls it.
+
+A SEAL is SealKeeper's signed credential for an agent or a service. This package wires the [`sealkeeper`](https://pypi.org/project/sealkeeper/) library into LangChain. Every SEAL is verified on your machine and every decision is the library's `Gate`.
+
+## Install
+
+```sh
+pip install langchain-sealkeeper
+```
+
+Python 3.10 or later. It depends on `sealkeeper`, `langchain-core` and `langchain`.
+
+## Look up
+
+`SealKeeperLookupTool` lets the model look a target up.
+
+```python
+from langchain.agents import create_agent
+from langchain_sealkeeper import SealKeeperLookupTool
+
+agent = create_agent(model, tools=[SealKeeperLookupTool()])
+```
+
+The tool is `sealkeeper_lookup`, with one argument, `target`. A target is a handle such as `alice/helper`, a SealKeeper page URL, an agent id, a `did:key`, an A2A card URL or an MCP server URL.
+
+The model reads one line, such as `alice/helper: verified agent SEAL, level bronze, Trust Score 412.` or `alice/helper: no verified SEAL (broken, bad_signature).`
+
+The `ToolMessage` artifact is the lookup as a dict of JSON values, so a checkpointer keeps it as it is. `verified` says whether the SEAL verified, and `seal` holds it when it did. Without one, `code` says why, as in the `sealkeeper` library's `Lookup`. A broken SEAL reads `verified` false and no level, kind or Trust Score.
+
+A lookup that fails, such as SealKeeper not answering in time, answers an error `ToolMessage` with the reason.
+
+## Gate an MCP server
+
+`SealGateInterceptor` checks an MCP server's SEAL before each call to one of its tools. It needs `langchain-mcp-adapters`.
+
+```python
+from langchain_mcp_adapters.client import MultiServerMCPClient
+from langchain_sealkeeper import SealGateInterceptor
+
+connections = {
+    "weather": {"transport": "streamable_http", "url": "https://mcp.example.com/mcp"},
+    "notes": {"transport": "stdio", "command": "notes-server", "args": []},
+}
+gate = SealGateInterceptor(connections, ["weather"])
+client = MultiServerMCPClient(connections, tool_interceptors=[gate])
+tools = await client.get_tools()
+```
+
+Pass it the same `connections` as the client. It reads each server's `url` from them at every call, as a service. Load the tools with `client.get_tools()`, or with `load_mcp_tools(session, server_name=...)` and the connection's name, since a tool loaded without its server's name is not gated.
+
+- A pass calls the tool.
+- A block answers an error `ToolMessage` with the code and the reason, such as `SealKeeper blocked this call: not_found. SealKeeper knows no agent or service by that target`. The tool is not called and the agent's run goes on. The message has no `name`, and outside a LangGraph `ToolNode` its `tool_call_id` is empty.
+- A server you do not name passes untouched.
+- A stdio server has no URL to check, so naming one raises `ValueError`.
+
+## Gate a remote agent
+
+`SealGateMiddleware` checks a target's SEAL before each call to a tool that calls it, such as a tool that sends a task to a remote A2A agent.
+
+```python
+from langchain.agents import create_agent
+from langchain_sealkeeper import SealGateMiddleware, SealTarget
+
+gate = SealGateMiddleware({
+    "ask_helper": SealTarget("agent", "alice/helper"),
+    "fetch_report": SealTarget("service", "https://mcp.example.com/mcp"),
+})
+agent = create_agent(model, tools=[ask_helper, fetch_report, search], middleware=[gate])
+```
+
+Each pinned tool name maps to a `SealTarget(kind, ref)`. `kind` is `"agent"` or `"service"`, and `ref` is any target the lookup takes. A block answers an error `ToolMessage` with the code and the reason, the tool is not called and the run goes on. A tool you do not pin passes untouched. It works with `invoke` and `ainvoke`.
+
+## The rules
+
+Both gates decide with a `sealkeeper.Gate` and its default rules. A pass needs a current, valid SEAL of the kind at bronze or above, and for a card or MCP server URL the SEAL must name that URL.
+
+`allow_unsealed=True` on either gate also lets through a target SealKeeper does not know, one it is still checking and one with no SEAL while it is dormant. A withheld or broken SEAL, a delisted target and SealKeeper unavailable still block.
+
+```python
+gate = SealGateInterceptor(connections, ["weather"], allow_unsealed=True)
+```
+
+The block codes are in the [`sealkeeper` README](https://pypi.org/project/sealkeeper/). Each decision writes one INFO line to the `sealkeeper` logger, never the SEAL, a full URL or the tool's arguments.
+
+## License
+
+MIT

langchain_sealkeeper-0.1.0/pyproject.toml

@@ -0,0 +1,65 @@
+[project]
+name = "langchain-sealkeeper"
+dynamic = ["version"]
+description = "LangChain tools and gates that check a SealKeeper SEAL before an agent calls an agent or an MCP server."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "The SealKeeper Authors" }]
+requires-python = ">=3.10"
+dependencies = [
+  "sealkeeper>=0.1.0,<0.2",
+  "langchain-core>=1.7.3,<2",
+  "langchain>=1.4.7,<2",
+]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.14",
+  "Typing :: Typed",
+]
+
+[project.urls]
+Homepage = "https://sealkeeper.run"
+"SEAL Standard" = "https://sealkeeper.run/seal/standard"
+Repository = "https://github.com/sealkeeper-dev/langchain-sealkeeper"
+Issues = "https://github.com/sealkeeper-dev/langchain-sealkeeper/issues"
+
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+path = "src/langchain_sealkeeper/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/langchain_sealkeeper"]
+
+[tool.hatch.build.targets.sdist]
+only-include = ["src/langchain_sealkeeper", "tests", "README.md", "LICENSE"]
+
+[dependency-groups]
+# langchain-tests and langchain-mcp-adapters are for the tests only.
+dev = [
+  "pytest>=8.3",
+  "ruff>=0.14",
+  "langchain-tests>=1.1.9",
+  "langchain-mcp-adapters>=0.3.2",
+]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 88
+include = ["*.py"]
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "UP", "B", "SIM", "RUF"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["langchain_sealkeeper", "harness"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+# Async tests run on anyio. pytest-asyncio comes with langchain-tests and
+# stays off.
+addopts = "--strict-markers -p no:asyncio"

langchain_sealkeeper-0.1.0/src/langchain_sealkeeper/__init__.py

@@ -0,0 +1,14 @@
+"""LangChain tools and gates on SealKeeper SEALs."""
+
+from ._version import __version__
+from .interceptor import SealGateInterceptor
+from .middleware import SealGateMiddleware, SealTarget
+from .tool import SealKeeperLookupTool
+
+__all__ = [
+    "SealGateInterceptor",
+    "SealGateMiddleware",
+    "SealKeeperLookupTool",
+    "SealTarget",
+    "__version__",
+]

langchain_sealkeeper-0.1.0/src/langchain_sealkeeper/_shared.py

@@ -0,0 +1,25 @@
+"""What the tool and both gates share. The User-Agent suffix, the gate both
+gates decide with and the line a block answers with."""
+
+from __future__ import annotations
+
+from sealkeeper import AsyncSealKeeper, Block, Gate, SealKeeper
+
+from ._version import __version__
+
+USER_AGENT_SUFFIX = f"langchain-sealkeeper/{__version__}"
+
+
+def default_gate(allow_unsealed: bool) -> Gate:
+    """A Gate with its default rules and allow_unsealed, whose lookups name
+    this package in their User-Agent."""
+    return Gate(
+        allow_unsealed=allow_unsealed,
+        client=SealKeeper(user_agent_suffix=USER_AGENT_SUFFIX),
+        async_client=AsyncSealKeeper(user_agent_suffix=USER_AGENT_SUFFIX),
+    )
+
+
+def blocked_text(block: Block) -> str:
+    """The error text of a blocked call, its code and its reason."""
+    return f"SealKeeper blocked this call: {block.code}. {block.reason}"

langchain_sealkeeper-0.1.0/src/langchain_sealkeeper/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

langchain_sealkeeper-0.1.0/src/langchain_sealkeeper/interceptor.py

@@ -0,0 +1,65 @@
+"""SealGateInterceptor, a tool interceptor for langchain-mcp-adapters that
+gates the tools of named MCP servers on each server's SEAL."""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable, Iterable, Mapping
+from typing import Any
+
+from langchain_core.messages import ToolMessage
+
+from ._shared import blocked_text, default_gate
+
+
+class SealGateInterceptor:
+    """Checks a server's SEAL before each call to one of its tools.
+
+    Pass it as MultiServerMCPClient(connections, tool_interceptors=[gate]),
+    with the same connections. servers names the servers to gate. Each call
+    to one of their tools asks the gate about that server's url, read from
+    connections at the call, as a service. A pass calls the tool. A block
+    answers an error ToolMessage with the code and the reason and never
+    calls it, so the agent's run goes on. That ToolMessage has no name,
+    and its tool_call_id is the one LangGraph's ToolNode passes the tool,
+    empty for a call made outside one. A server not named passes untouched.
+    A stdio server has no URL to check and is refused. The gate sees a
+    tool's server only when the adapter loaded it with the server's name,
+    as client.get_tools() does. allow_unsealed also passes a server
+    SealKeeper does not know, one it is still checking and one with no SEAL
+    for dormancy.
+    """
+
+    def __init__(
+        self,
+        connections: Mapping[str, Mapping[str, Any]],
+        servers: Iterable[str],
+        *,
+        allow_unsealed: bool = False,
+    ) -> None:
+        if isinstance(servers, str):
+            raise TypeError("servers must be a list of server names")
+        names = tuple(servers)
+        for name in names:
+            connection = connections.get(name)
+            if connection is None:
+                raise ValueError(f"no connection is named {name!r}")
+            if connection.get("transport") == "stdio":
+                raise ValueError(f"{name!r} is a stdio server, with no URL to check")
+        self._connections = connections
+        self._servers = frozenset(names)
+        self._gate = default_gate(allow_unsealed)
+
+    async def __call__(
+        self, request: Any, handler: Callable[[Any], Awaitable[Any]]
+    ) -> Any:
+        if request.server_name not in self._servers:
+            return await handler(request)
+        connection = self._connections.get(request.server_name) or {}
+        decision = await self._gate.acheck(connection.get("url"), "service")
+        if decision.passed:
+            return await handler(request)
+        return ToolMessage(
+            content=blocked_text(decision),
+            tool_call_id=getattr(request.runtime, "tool_call_id", None) or "",
+            status="error",
+        )

langchain_sealkeeper-0.1.0/src/langchain_sealkeeper/middleware.py

@@ -0,0 +1,89 @@
+"""SealGateMiddleware, agent middleware that gates the tools which call a
+remote agent or service on that target's SEAL."""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable, Mapping
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Literal
+
+from langchain.agents.middleware import AgentMiddleware, ToolCallRequest
+from langchain_core.messages import ToolMessage
+from sealkeeper import Block
+
+from ._shared import blocked_text, default_gate
+
+if TYPE_CHECKING:
+    # The type langchain's own hooks answer with.
+    from langgraph.types import Command
+
+
+@dataclass(frozen=True)
+class SealTarget:
+    """What a gated tool calls. kind is agent or service, ref the target to
+    look up, such as a handle, a card URL or an MCP server URL."""
+
+    kind: Literal["agent", "service"]
+    ref: str
+
+    def __post_init__(self) -> None:
+        if self.kind not in ("agent", "service"):
+            raise ValueError('kind must be "agent" or "service"')
+        if not isinstance(self.ref, str):
+            raise TypeError("ref must be a string")
+
+
+class SealGateMiddleware(AgentMiddleware):
+    """Checks a target's SEAL before each call to a tool pinned to it.
+
+    targets maps a tool name to the SealTarget it calls. A pass calls the
+    tool. A block answers an error ToolMessage with the code and the reason
+    and never calls it, so the agent's run goes on. A tool not pinned passes
+    untouched. allow_unsealed also passes a target SealKeeper does not
+    know, one it is still checking and one with no SEAL for dormancy.
+    """
+
+    def __init__(
+        self, targets: Mapping[str, SealTarget], *, allow_unsealed: bool = False
+    ) -> None:
+        super().__init__()
+        for target in targets.values():
+            if not isinstance(target, SealTarget):
+                raise TypeError("each target must be a SealTarget")
+        self._targets = dict(targets)
+        self._gate = default_gate(allow_unsealed)
+
+    def wrap_tool_call(
+        self,
+        request: ToolCallRequest,
+        handler: Callable[[ToolCallRequest], ToolMessage | Command[Any]],
+    ) -> ToolMessage | Command[Any]:
+        target = self._targets.get(request.tool_call["name"])
+        if target is None:
+            return handler(request)
+        decision = self._gate.check(target.ref, target.kind)
+        if decision.passed:
+            return handler(request)
+        return _blocked(request, decision)
+
+    async def awrap_tool_call(
+        self,
+        request: ToolCallRequest,
+        handler: Callable[[ToolCallRequest], Awaitable[ToolMessage | Command[Any]]],
+    ) -> ToolMessage | Command[Any]:
+        target = self._targets.get(request.tool_call["name"])
+        if target is None:
+            return await handler(request)
+        decision = await self._gate.acheck(target.ref, target.kind)
+        if decision.passed:
+            return await handler(request)
+        return _blocked(request, decision)
+
+
+def _blocked(request: ToolCallRequest, block: Block) -> ToolMessage:
+    return ToolMessage(
+        content=blocked_text(block),
+        name=request.tool_call["name"],
+        tool_call_id=request.tool_call["id"],
+        status="error",
+    )

langchain_sealkeeper-0.1.0/src/langchain_sealkeeper/tool.py

@@ -0,0 +1,78 @@
+"""SealKeeperLookupTool, a LangChain tool that looks a target up on
+SealKeeper and verifies its SEAL."""
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Any, Literal
+
+from langchain_core.tools import BaseTool, ToolException
+from pydantic import BaseModel, Field, PrivateAttr
+from sealkeeper import AsyncSealKeeper, Lookup, SealKeeper, SealKeeperError
+
+from ._shared import USER_AGENT_SUFFIX
+
+
+class LookupInput(BaseModel):
+    target: str = Field(
+        description=(
+            "The agent or service to look up. A handle such as alice/helper, "
+            "a SealKeeper page URL, an agent id, a did:key, an A2A card URL "
+            "or an MCP server URL."
+        )
+    )
+
+
+class SealKeeperLookupTool(BaseTool):
+    """Looks a target up on SealKeeper and verifies its SEAL.
+
+    The model reads one short line. The artifact is the lookup as a dict
+    that holds only JSON values, so a checkpointer stores it as it is.
+    level, kind and trust come only from a SEAL that verified, so a broken
+    SEAL reads verified false and none of them. A lookup that fails answers
+    an error ToolMessage with SealKeeper's line.
+    """
+
+    name: str = "sealkeeper_lookup"
+    description: str = (
+        "Look up an AI agent or service on SealKeeper and verify its SEAL, "
+        "SealKeeper's signed credential. Answers whether a SEAL verified, "
+        "and its kind, level and Trust Score when one did."
+    )
+    args_schema: type[BaseModel] = LookupInput
+    response_format: Literal["content", "content_and_artifact"] = "content_and_artifact"
+    handle_tool_error: bool = True
+    _client: SealKeeper | None = PrivateAttr(default=None)
+    _async_client: AsyncSealKeeper | None = PrivateAttr(default=None)
+
+    def _run(self, target: str) -> tuple[str, dict[str, Any]]:
+        if self._client is None:
+            self._client = SealKeeper(user_agent_suffix=USER_AGENT_SUFFIX)
+        try:
+            found = self._client.lookup(target)
+        except SealKeeperError as error:
+            raise ToolException(str(error)) from None
+        return line_of(target, found), artifact_of(found)
+
+    async def _arun(self, target: str) -> tuple[str, dict[str, Any]]:
+        if self._async_client is None:
+            self._async_client = AsyncSealKeeper(user_agent_suffix=USER_AGENT_SUFFIX)
+        try:
+            found = await self._async_client.lookup(target)
+        except SealKeeperError as error:
+            raise ToolException(str(error)) from None
+        return line_of(target, found), artifact_of(found)
+
+
+def line_of(target: str, found: Lookup) -> str:
+    """The one line the model reads."""
+    if found.verified:
+        trust = "" if found.trust is None else f", Trust Score {found.trust}"
+        return f"{target}: verified {found.kind} SEAL, level {found.level}{trust}."
+    why = found.code if found.broken is None else f"{found.code}, {found.broken}"
+    return f"{target}: no verified SEAL ({why})."
+
+
+def artifact_of(found: Lookup) -> dict[str, Any]:
+    """The lookup as a dict of JSON values, with verified beside its fields."""
+    return {"verified": found.verified, **dataclasses.asdict(found)}

langchain_sealkeeper-0.1.0/tests/conftest.py

@@ -0,0 +1,26 @@
+import pytest
+
+from harness import RecordedSealKeeper, async_client, sync_client
+from langchain_sealkeeper import _shared as shared
+from langchain_sealkeeper import tool as tool_module
+
+
+# Async tests run on asyncio, the loop httpx and LangChain use by default.
+@pytest.fixture
+def anyio_backend() -> str:
+    return "asyncio"
+
+
+@pytest.fixture(autouse=True)
+def sealkeeper(monkeypatch) -> RecordedSealKeeper:
+    """The recorded SealKeeper behind every client the package makes, so no
+    test reaches the network."""
+    server = RecordedSealKeeper()
+    for module in (shared, tool_module):
+        monkeypatch.setattr(
+            module, "SealKeeper", lambda **kw: sync_client(server, **kw)
+        )
+        monkeypatch.setattr(
+            module, "AsyncSealKeeper", lambda **kw: async_client(server, **kw)
+        )
+    return server