substrate-haystack 0.1.1__py3-none-any.whl

substrate_haystack/__init__.py

@@ -0,0 +1,11 @@
+"""
+substrate-haystack -- SUBSTRATE memory components for Haystack pipelines.
+
+Provides retriever and writer components that connect Haystack to
+SUBSTRATE's causal memory, emotional state, and identity continuity.
+"""
+from substrate_haystack.retriever import SubstrateMemoryRetriever
+from substrate_haystack.writer import SubstrateMemoryWriter
+
+__all__ = ["SubstrateMemoryRetriever", "SubstrateMemoryWriter"]
+__version__ = "0.1.0"

substrate_haystack/client.py

@@ -0,0 +1,157 @@
+"""
+Synchronous HTTP client for the SUBSTRATE MCP server (JSON-RPC over HTTP).
+
+The SUBSTRATE MCP endpoint accepts standard JSON-RPC 2.0 requests with
+Bearer token authentication. This client wraps that transport into a
+clean Python interface for use by Haystack components.
+"""
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass
+from typing import Any
+
+import httpx
+
+logger = logging.getLogger("substrate_haystack.client")
+
+_DEFAULT_BASE_URL = "https://substrate.garmolabs.com/mcp-server/mcp"
+_DEFAULT_TIMEOUT = 30.0
+_JSONRPC_VERSION = "2.0"
+
+
+class SubstrateClientError(Exception):
+    """Raised when a SUBSTRATE MCP request fails."""
+
+    def __init__(self, message: str, code: int = -1) -> None:
+        super().__init__(message)
+        self.code = code
+
+
+@dataclass(frozen=True)
+class SubstrateClientConfig:
+    """Immutable configuration for the SUBSTRATE MCP client."""
+
+    api_key: str
+    base_url: str = _DEFAULT_BASE_URL
+    timeout: float = _DEFAULT_TIMEOUT
+
+
+class SubstrateClient:
+    """
+    Synchronous JSON-RPC client for the SUBSTRATE MCP server.
+
+    All tool calls go through ``call_tool`` which handles the JSON-RPC
+    envelope, authentication, error handling, and response unwrapping.
+    """
+
+    def __init__(self, config: SubstrateClientConfig) -> None:
+        if not config.api_key:
+            raise ValueError("api_key is required -- set SUBSTRATE_API_KEY")
+        self._config = config
+        self._request_id = 0
+        self._http = httpx.Client(
+            base_url="",
+            timeout=config.timeout,
+            headers={
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {config.api_key}",
+            },
+        )
+        self._session_id: str | None = None
+
+    # -- Public API --------------------------------------------------------
+
+    def call_tool(self, name: str, arguments: dict[str, Any] | None = None) -> Any:
+        """
+        Call a SUBSTRATE MCP tool by name and return the result content.
+
+        Raises ``SubstrateClientError`` on JSON-RPC errors or HTTP failures.
+        """
+        self._request_id += 1
+        payload = {
+            "jsonrpc": _JSONRPC_VERSION,
+            "id": self._request_id,
+            "method": "tools/call",
+            "params": {
+                "name": name,
+                "arguments": arguments or {},
+            },
+        }
+        return self._send(payload)
+
+    def initialize(self) -> dict[str, Any]:
+        """Perform the MCP initialize handshake."""
+        self._request_id += 1
+        payload = {
+            "jsonrpc": _JSONRPC_VERSION,
+            "id": self._request_id,
+            "method": "initialize",
+            "params": {
+                "protocolVersion": "2024-11-05",
+                "capabilities": {},
+                "clientInfo": {
+                    "name": "substrate-haystack",
+                    "version": "0.1.0",
+                },
+            },
+        }
+        return self._send(payload)
+
+    def close(self) -> None:
+        """Close the HTTP client and release resources."""
+        self._http.close()
+
+    # -- Internal ----------------------------------------------------------
+
+    def _send(self, payload: dict[str, Any]) -> Any:
+        """Send a JSON-RPC request and return the unwrapped result."""
+        headers: dict[str, str] = {}
+        if self._session_id:
+            headers["Mcp-Session-Id"] = self._session_id
+
+        try:
+            response = self._http.post(
+                self._config.base_url,
+                json=payload,
+                headers=headers,
+            )
+        except httpx.HTTPError as exc:
+            raise SubstrateClientError(f"HTTP request failed: {exc}") from exc
+
+        session_id = response.headers.get("Mcp-Session-Id")
+        if session_id:
+            self._session_id = session_id
+
+        if response.status_code == 401:
+            raise SubstrateClientError("Authentication failed -- check your SUBSTRATE_API_KEY", code=-32000)
+
+        if response.status_code == 429:
+            raise SubstrateClientError("Rate limit exceeded -- slow down or upgrade your plan", code=-32029)
+
+        if response.status_code not in (200, 202):
+            raise SubstrateClientError(
+                f"Unexpected HTTP {response.status_code}: {response.text[:200]}",
+                code=response.status_code,
+            )
+
+        try:
+            body = response.json()
+        except (json.JSONDecodeError, ValueError) as exc:
+            raise SubstrateClientError(f"Invalid JSON response: {exc}") from exc
+
+        if "error" in body:
+            err = body["error"]
+            raise SubstrateClientError(
+                err.get("message", "Unknown error"),
+                code=err.get("code", -1),
+            )
+
+        return body.get("result", {})
+
+    def __enter__(self) -> SubstrateClient:
+        return self
+
+    def __exit__(self, *_: Any) -> None:
+        self.close()

substrate_haystack/retriever.py

@@ -0,0 +1,219 @@
+"""
+SUBSTRATE Memory Retriever for Haystack.
+
+A Haystack component that retrieves documents from SUBSTRATE's causal
+memory engine using hybrid search (semantic + keyword), and optionally
+enriches results with the entity's emotional state vector.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import os
+from typing import Any, Optional
+
+from haystack import Document, component, default_from_dict, default_to_dict
+
+from substrate_haystack.client import (
+    SubstrateClient,
+    SubstrateClientConfig,
+    SubstrateClientError,
+)
+
+logger = logging.getLogger("substrate_haystack.retriever")
+
+
+def _extract_text(result: Any) -> str:
+    """Extract text content from a SUBSTRATE MCP tool result."""
+    if isinstance(result, str):
+        return result
+    if isinstance(result, dict):
+        content = result.get("content", [])
+        if isinstance(content, list):
+            parts = [
+                block.get("text", "")
+                for block in content
+                if isinstance(block, dict) and block.get("type") == "text"
+            ]
+            return "\n".join(parts)
+        return json.dumps(result, indent=2)
+    return str(result)
+
+
+def _parse_json_safe(text: str) -> dict[str, Any]:
+    """Parse JSON from text, returning an empty dict on failure."""
+    try:
+        return json.loads(text)
+    except (json.JSONDecodeError, TypeError):
+        return {}
+
+
+@component
+class SubstrateMemoryRetriever:
+    """
+    Retrieves documents from SUBSTRATE's causal memory using hybrid search.
+
+    This component calls SUBSTRATE's ``hybrid_search`` tool (falling back
+    to ``memory_search`` on the free tier) and returns results as Haystack
+    ``Document`` objects. It also fetches the entity's emotional state
+    via ``get_emotion_state`` and exposes it as a separate output.
+
+    Usage in a Haystack pipeline::
+
+        from haystack import Pipeline
+        from substrate_haystack import SubstrateMemoryRetriever
+
+        retriever = SubstrateMemoryRetriever(api_key="sk_sub_...")
+
+        pipe = Pipeline()
+        pipe.add_component("retriever", retriever)
+        pipe.add_component("llm", some_generator)
+        pipe.connect("retriever.documents", "llm.documents")
+
+        result = pipe.run({"retriever": {"query": "What did we discuss?"}})
+    """
+
+    def __init__(
+        self,
+        api_key: str = "",
+        base_url: str = "https://substrate.garmolabs.com/mcp-server/mcp",
+        timeout: float = 30.0,
+        include_emotion: bool = True,
+    ) -> None:
+        """
+        Initialize the retriever.
+
+        Args:
+            api_key: SUBSTRATE API key. Falls back to ``SUBSTRATE_API_KEY`` env var.
+            base_url: MCP server endpoint URL.
+            timeout: HTTP request timeout in seconds.
+            include_emotion: Whether to fetch emotional context alongside results.
+        """
+        resolved_key = api_key or os.environ.get("SUBSTRATE_API_KEY", "")
+        if not resolved_key:
+            raise ValueError(
+                "SUBSTRATE API key required. Pass api_key= or set SUBSTRATE_API_KEY env var."
+            )
+        self._api_key = resolved_key
+        self._base_url = base_url
+        self._timeout = timeout
+        self._include_emotion = include_emotion
+        self._client: SubstrateClient | None = None
+
+    def _get_client(self) -> SubstrateClient:
+        """Lazy-initialize the HTTP client."""
+        if self._client is None:
+            self._client = SubstrateClient(
+                SubstrateClientConfig(
+                    api_key=self._api_key,
+                    base_url=self._base_url,
+                    timeout=self._timeout,
+                )
+            )
+        return self._client
+
+    @component.output_types(documents=list[Document], entity_state=dict)
+    def run(
+        self,
+        query: str,
+        top_k: int = 5,
+    ) -> dict[str, Any]:
+        """
+        Retrieve documents from SUBSTRATE memory.
+
+        Args:
+            query: The search query string.
+            top_k: Maximum number of documents to return.
+
+        Returns:
+            A dict with ``documents`` (list of Haystack Documents) and
+            ``entity_state`` (dict with emotional context if enabled).
+        """
+        client = self._get_client()
+        documents = self._search(client, query, top_k)
+        entity_state: dict[str, Any] = {}
+
+        if self._include_emotion:
+            entity_state = self._get_emotion(client)
+
+        return {"documents": documents, "entity_state": entity_state}
+
+    def _search(
+        self, client: SubstrateClient, query: str, top_k: int
+    ) -> list[Document]:
+        """Execute hybrid search and convert results to Documents."""
+        try:
+            result = client.call_tool(
+                "hybrid_search",
+                {"query": query, "top_k": top_k},
+            )
+            return self._parse_results(result)
+        except SubstrateClientError as exc:
+            if exc.code == -32000 or "not available" in str(exc).lower():
+                logger.info("hybrid_search unavailable, falling back to memory_search")
+                return self._fallback_search(client, query, top_k)
+            raise
+
+    def _fallback_search(
+        self, client: SubstrateClient, query: str, top_k: int
+    ) -> list[Document]:
+        """Use basic memory_search when hybrid_search is unavailable."""
+        try:
+            result = client.call_tool("memory_search", {"query": query})
+            return self._parse_results(result)[:top_k]
+        except SubstrateClientError as exc:
+            logger.error("Fallback memory_search failed: %s", exc)
+            return []
+
+    def _parse_results(self, result: Any) -> list[Document]:
+        """Convert MCP tool output into Haystack Document objects."""
+        text = _extract_text(result)
+        parsed = _parse_json_safe(text)
+
+        # If the result has a structured "results" list, convert each item
+        if isinstance(parsed, dict) and "results" in parsed:
+            docs: list[Document] = []
+            for item in parsed["results"]:
+                if isinstance(item, dict):
+                    content = item.get("text", item.get("content", json.dumps(item)))
+                    meta = {
+                        k: v for k, v in item.items() if k not in ("text", "content")
+                    }
+                    meta["source"] = "substrate"
+                    docs.append(Document(content=content, meta=meta))
+                else:
+                    docs.append(
+                        Document(content=str(item), meta={"source": "substrate"})
+                    )
+            return docs
+
+        # Single text result
+        if text.strip():
+            return [Document(content=text, meta={"source": "substrate"})]
+        return []
+
+    def _get_emotion(self, client: SubstrateClient) -> dict[str, Any]:
+        """Fetch the entity's emotional state vector."""
+        try:
+            result = client.call_tool("get_emotion_state")
+            text = _extract_text(result)
+            parsed = _parse_json_safe(text)
+            return parsed if parsed else {"raw": text}
+        except SubstrateClientError as exc:
+            logger.warning("Could not fetch emotion state: %s", exc)
+            return {"error": str(exc)}
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize for Haystack pipeline export."""
+        return default_to_dict(
+            self,
+            api_key=self._api_key,
+            base_url=self._base_url,
+            timeout=self._timeout,
+            include_emotion=self._include_emotion,
+        )
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> SubstrateMemoryRetriever:
+        """Deserialize from Haystack pipeline export."""
+        return default_from_dict(cls, data)

substrate_haystack/writer.py

@@ -0,0 +1,159 @@
+"""
+SUBSTRATE Memory Writer for Haystack.
+
+A Haystack component that stores documents into SUBSTRATE's causal memory
+engine via the ``respond`` tool. Each document is processed through the
+entity's causal memory, values, and reflection layers.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import os
+from typing import Any
+
+from haystack import Document, component, default_from_dict, default_to_dict
+
+from substrate_haystack.client import (
+    SubstrateClient,
+    SubstrateClientConfig,
+    SubstrateClientError,
+)
+
+logger = logging.getLogger("substrate_haystack.writer")
+
+
+def _extract_text(result: Any) -> str:
+    """Extract text content from a SUBSTRATE MCP tool result."""
+    if isinstance(result, str):
+        return result
+    if isinstance(result, dict):
+        content = result.get("content", [])
+        if isinstance(content, list):
+            parts = [
+                block.get("text", "")
+                for block in content
+                if isinstance(block, dict) and block.get("type") == "text"
+            ]
+            return "\n".join(parts)
+        return json.dumps(result, indent=2)
+    return str(result)
+
+
+@component
+class SubstrateMemoryWriter:
+    """
+    Writes documents into SUBSTRATE's causal memory via the ``respond`` tool.
+
+    Each document's content is sent as a message to the SUBSTRATE entity,
+    which processes it through its full cognitive pipeline (causal memory,
+    values alignment, reflection layers) before storing.
+
+    Usage in a Haystack pipeline::
+
+        from haystack import Pipeline
+        from substrate_haystack import SubstrateMemoryWriter
+
+        writer = SubstrateMemoryWriter(api_key="sk_sub_...")
+
+        pipe = Pipeline()
+        pipe.add_component("writer", writer)
+
+        pipe.run({"writer": {"documents": [Document(content="Remember this.")]}})
+    """
+
+    def __init__(
+        self,
+        api_key: str = "",
+        base_url: str = "https://substrate.garmolabs.com/mcp-server/mcp",
+        timeout: float = 30.0,
+    ) -> None:
+        """
+        Initialize the writer.
+
+        Args:
+            api_key: SUBSTRATE API key. Falls back to ``SUBSTRATE_API_KEY`` env var.
+            base_url: MCP server endpoint URL.
+            timeout: HTTP request timeout in seconds.
+        """
+        resolved_key = api_key or os.environ.get("SUBSTRATE_API_KEY", "")
+        if not resolved_key:
+            raise ValueError(
+                "SUBSTRATE API key required. Pass api_key= or set SUBSTRATE_API_KEY env var."
+            )
+        self._api_key = resolved_key
+        self._base_url = base_url
+        self._timeout = timeout
+        self._client: SubstrateClient | None = None
+
+    def _get_client(self) -> SubstrateClient:
+        """Lazy-initialize the HTTP client."""
+        if self._client is None:
+            self._client = SubstrateClient(
+                SubstrateClientConfig(
+                    api_key=self._api_key,
+                    base_url=self._base_url,
+                    timeout=self._timeout,
+                )
+            )
+        return self._client
+
+    @component.output_types(documents_written=int, responses=list[str])
+    def run(self, documents: list[Document]) -> dict[str, Any]:
+        """
+        Store documents in SUBSTRATE memory.
+
+        Each document is sent to the entity via ``respond``. Document
+        metadata is serialized and appended to the message for context.
+
+        Args:
+            documents: List of Haystack Documents to store.
+
+        Returns:
+            A dict with ``documents_written`` (count) and ``responses``
+            (the entity's response for each stored document).
+        """
+        client = self._get_client()
+        responses: list[str] = []
+        written = 0
+
+        for doc in documents:
+            message = doc.content or ""
+            if not message.strip():
+                logger.warning("Skipping empty document")
+                continue
+
+            # Append metadata if present
+            if doc.meta:
+                filtered_meta = {
+                    k: v
+                    for k, v in doc.meta.items()
+                    if k != "source"  # Don't echo back our own source tag
+                }
+                if filtered_meta:
+                    message = f"{message}\n\n[metadata: {json.dumps(filtered_meta)}]"
+
+            try:
+                result = client.call_tool("respond", {"message": message})
+                response_text = _extract_text(result)
+                responses.append(response_text)
+                written += 1
+            except SubstrateClientError as exc:
+                logger.error("Failed to store document: %s", exc)
+                responses.append(f"[error: {exc}]")
+
+        return {"documents_written": written, "responses": responses}
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize for Haystack pipeline export."""
+        return default_to_dict(
+            self,
+            api_key=self._api_key,
+            base_url=self._base_url,
+            timeout=self._timeout,
+        )
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> SubstrateMemoryWriter:
+        """Deserialize from Haystack pipeline export."""
+        return default_from_dict(cls, data)

substrate_haystack-0.1.1.dist-info/METADATA

@@ -0,0 +1,165 @@
+Metadata-Version: 2.4
+Name: substrate-haystack
+Version: 0.1.1
+Summary: SUBSTRATE memory components for Haystack -- causal memory, emotion, and identity retrieval and storage.
+Project-URL: Homepage, https://garmolabs.com/substrate.html
+Project-URL: Documentation, https://github.com/PKaldone/substrate-mcp
+Project-URL: Repository, https://github.com/PKaldone/substrate-mcp
+Project-URL: Issues, https://garmolabs.com/substrate.html
+Author-email: Garmo Labs <hello@garmolabs.com>
+License-Expression: MIT
+Keywords: ai,causal-memory,emotional-state,garmo-labs,haystack,mcp,memory,retriever,substrate
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: haystack-ai>=2.0
+Requires-Dist: httpx>=0.25
+Description-Content-Type: text/markdown
+
+# substrate-haystack
+
+SUBSTRATE memory components for [Haystack](https://haystack.deepset.ai/) pipelines. Retriever and writer that connect Haystack to [SUBSTRATE](https://garmolabs.com/substrate.html)'s causal memory, emotional state, and identity continuity.
+
+## What SUBSTRATE adds to Haystack
+
+- **Causal memory retrieval** -- episodes linked by cause-effect rules, not just vector similarity
+- **Emotional context output** -- retriever exposes the entity's emotional state alongside documents
+- **Persistent storage** -- writer stores documents through the entity's full cognitive pipeline
+- **Hybrid search** -- semantic + keyword retrieval across the entity's full knowledge store
+- **Identity continuity** -- cryptographically verified entity state persists across sessions
+
+## Installation
+
+```bash
+pip install substrate-haystack
+```
+
+## Quick start: Retrieval pipeline
+
+```python
+import os
+from haystack import Pipeline
+from haystack.components.generators import OpenAIGenerator
+from haystack.components.builders import PromptBuilder
+from substrate_haystack import SubstrateMemoryRetriever
+
+retriever = SubstrateMemoryRetriever(
+    api_key=os.environ["SUBSTRATE_API_KEY"],
+)
+
+prompt_builder = PromptBuilder(
+    template="""
+    Context from SUBSTRATE memory:
+    {% for doc in documents %}
+    - {{ doc.content }}
+    {% endfor %}
+
+    Entity emotional state: {{ entity_state }}
+
+    Question: {{ query }}
+    Answer:
+    """
+)
+
+generator = OpenAIGenerator(model="gpt-4o")
+
+pipe = Pipeline()
+pipe.add_component("retriever", retriever)
+pipe.add_component("prompt_builder", prompt_builder)
+pipe.add_component("llm", generator)
+
+pipe.connect("retriever.documents", "prompt_builder.documents")
+pipe.connect("retriever.entity_state", "prompt_builder.entity_state")
+pipe.connect("prompt_builder", "llm")
+
+result = pipe.run({
+    "retriever": {"query": "What patterns have we identified?"},
+    "prompt_builder": {"query": "What patterns have we identified?"},
+})
+
+print(result["llm"]["replies"][0])
+```
+
+## Quick start: Writing to memory
+
+```python
+from haystack import Document, Pipeline
+from substrate_haystack import SubstrateMemoryWriter
+
+writer = SubstrateMemoryWriter(
+    api_key=os.environ["SUBSTRATE_API_KEY"],
+)
+
+pipe = Pipeline()
+pipe.add_component("writer", writer)
+
+result = pipe.run({
+    "writer": {
+        "documents": [
+            Document(content="The team decided to use event sourcing for the audit trail."),
+            Document(content="Performance testing showed 99th percentile at 45ms."),
+        ]
+    }
+})
+
+print(f"Stored {result['writer']['documents_written']} documents")
+```
+
+## Components
+
+### SubstrateMemoryRetriever
+
+Retrieves documents from SUBSTRATE memory using hybrid search.
+
+**Inputs:**
+| Name    | Type  | Description                          |
+|---------|-------|--------------------------------------|
+| `query` | `str` | Search query string                  |
+| `top_k` | `int` | Maximum results to return (default 5)|
+
+**Outputs:**
+| Name           | Type             | Description                              |
+|----------------|------------------|------------------------------------------|
+| `documents`    | `list[Document]` | Retrieved documents from SUBSTRATE memory|
+| `entity_state` | `dict`           | Entity emotional state (UASV dimensions) |
+
+**Parameters:**
+| Parameter         | Default                                           | Description                         |
+|-------------------|---------------------------------------------------|-------------------------------------|
+| `api_key`         | `$SUBSTRATE_API_KEY`                               | Your SUBSTRATE API key              |
+| `base_url`        | `https://substrate.garmolabs.com/mcp-server/mcp`  | MCP server endpoint                 |
+| `timeout`         | `30.0`                                             | HTTP request timeout (seconds)      |
+| `include_emotion` | `True`                                             | Fetch emotional context with results|
+
+### SubstrateMemoryWriter
+
+Stores documents into SUBSTRATE memory via the `respond` tool.
+
+**Inputs:**
+| Name        | Type             | Description                  |
+|-------------|------------------|------------------------------|
+| `documents` | `list[Document]` | Documents to store in memory |
+
+**Outputs:**
+| Name                | Type         | Description                            |
+|---------------------|--------------|----------------------------------------|
+| `documents_written` | `int`        | Number of documents successfully stored|
+| `responses`         | `list[str]`  | Entity responses for each document     |
+
+## API key
+
+Get your API key at [garmolabs.com](https://garmolabs.com). The free tier includes `memory_search` and `get_emotion_state`. Upgrade to Pro for `hybrid_search` and `get_trust_state`.
+
+## License
+
+MIT -- see [LICENSE](LICENSE) for details.
+
+Built by [Garmo Labs](https://garmolabs.com).

substrate_haystack-0.1.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+substrate_haystack/__init__.py,sha256=dJwNnK_IBoyNh3QdOL0sYNTzXr5iMqW0vKZcPMcDXvo,431
+substrate_haystack/client.py,sha256=jyPDS1-gbI7izPtXTrKbVC5c_GyVjDAIb5rdqFJ4IYk,4978
+substrate_haystack/retriever.py,sha256=OswJNX2nK_fI1o7MSY7MjPRdVz9WiKQ-_eWZuNzTUi0,7782
+substrate_haystack/writer.py,sha256=MwDs1381JgJv0kX7PtsyJn3vXnRmwxxZ-wOadfNKWy8,5247
+substrate_haystack-0.1.1.dist-info/METADATA,sha256=w2C9es5VM1K5SdAO8TQ97bgIgyadVZJsrckTqITFlEk,6143
+substrate_haystack-0.1.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+substrate_haystack-0.1.1.dist-info/RECORD,,

substrate_haystack-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any