thread-recall 0.1.0__py3-none-any.whl

thread_recall/__init__.py

@@ -0,0 +1,10 @@
+"""thread-recall: governed, on-prem conversation memory for AI agents.
+
+Per-thread history (recency) and semantic recall (nearest-neighbour over
+embeddings), with optional PII masking on write and tamper-evident audit.
+Part of the Governed Agent Stack.
+"""
+from thread_recall.store import Memory, Turn
+
+__version__ = "0.1.0"
+__all__ = ["Memory", "Turn", "__version__"]

thread_recall/cli.py

@@ -0,0 +1,46 @@
+"""Command line: a quick zero-config demo of governed agent memory."""
+from __future__ import annotations
+
+import argparse
+
+from thread_recall import __version__
+from thread_recall.store import Memory
+
+
+def cmd_demo(_args) -> int:
+    mem = Memory(":memory:")
+    thread = "demo-conversation"
+
+    # toy 3-dim embeddings just to show semantic recall without a model
+    mem.remember(thread, "user", "How much MRR did the pro plan make?", embedding=[1, 0, 0])
+    mem.remember(thread, "assistant", "Pro plan MRR was 297.", embedding=[0.9, 0.1, 0])
+    mem.remember(thread, "user", "What's the weather like?", embedding=[0, 0, 1])
+
+    print("thread-recall demo  (in-memory SQLite, no model)\n")
+    print("Recent turns (chronological):")
+    for t in mem.recent(thread):
+        print(f"  [{t.role}] {t.content}")
+
+    print("\nSemantic recall for a revenue-ish query [1,0,0] (top 2):")
+    for t in mem.search(thread, [1, 0, 0], k=2):
+        print(f"  {t.score:.2f}  [{t.role}] {t.content}")
+
+    print("\nWith mask=True (pii-veil, if installed) content is scrubbed before")
+    print("storage; with audit=True every write lands in an agent-blackbox ledger.")
+    mem.close()
+    return 0
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(prog="thread-recall", description=__doc__)
+    parser.add_argument("--version", action="version", version=f"thread-recall {__version__}")
+    sub = parser.add_subparsers(dest="cmd")
+    sub.add_parser("demo", help="run a zero-config in-memory demo")
+    args = parser.parse_args()
+    if args.cmd == "demo":
+        raise SystemExit(cmd_demo(args))
+    parser.print_help()
+
+
+if __name__ == "__main__":
+    main()

thread_recall/mcp_server.py

@@ -0,0 +1,157 @@
+"""thread-recall-mcp: expose governed agent memory as MCP tools.
+
+An agent calls ``remember`` to store a turn and ``recall`` to retrieve relevant
+past turns, instead of holding unbounded raw history in its context. The
+governance is on the write side: PII is masked before anything is stored (via
+pii-veil when installed), so the long-term memory never retains raw PII, and
+every write can be mirrored into a tamper-evident audit ledger.
+
+Isolation: every thread is namespaced by an ``actor`` -- the authenticated
+principal. A caller can only reach threads under its own actor, so a raw
+``thread_id`` is no longer a key into anyone else's memory (no cross-thread
+read, poison, or mass-delete). The governed gateway sets ``actor`` from the
+caller's token and does not let the client override it; standalone, set
+``THREAD_RECALL_ACTOR`` (or pass ``actor``), else all callers share one
+namespace. The caller always sees its own plain ``thread_id`` back.
+
+Configuration (environment):
+  THREAD_RECALL_DB        SQLite path for the store (default: logs/recall-mem.db)
+  THREAD_RECALL_MASK      mask PII on write (default on; set 0 to disable)
+  THREAD_RECALL_AUDIT     mirror writes to agent-blackbox (default off; set 1 on)
+  THREAD_RECALL_ACTOR     default principal when no actor is passed (default: shared)
+  THREAD_RECALL_EMBED     hashing (default) | ollama
+  THREAD_RECALL_OLLAMA_*  HOST / MODEL overrides for the Ollama embedder
+"""
+
+from __future__ import annotations
+
+import hashlib
+import math
+import os
+import re
+from typing import Any
+
+from fastmcp import FastMCP
+
+from thread_recall.store import Memory
+
+_TOKEN = re.compile(r"[a-z0-9]+")
+_ON = {"1", "true", "yes", "on"}
+_SEP = "\x1f"  # unit separator: partitions the store by actor, unseen by callers
+
+
+def _principal(actor: str | None) -> str:
+    """The authenticated identity a thread belongs to. The gateway supplies it."""
+    return (actor or os.environ.get("THREAD_RECALL_ACTOR", "shared")).strip() or "shared"
+
+
+def _key(actor: str | None, thread_id: str) -> str:
+    """Namespace a thread by its actor so ids cannot collide across principals."""
+    return f"{_principal(actor)}{_SEP}{thread_id}"
+
+
+def _plain(namespaced: str) -> str:
+    """Strip the actor namespace so the caller sees the thread_id it passed in."""
+    return namespaced.split(_SEP, 1)[1] if _SEP in namespaced else namespaced
+
+
+def _view(turn: dict) -> dict:
+    turn["thread_id"] = _plain(turn.get("thread_id", ""))
+    return turn
+
+
+def _hash_embed(text: str, dim: int = 256) -> list[float]:
+    """Deterministic, offline bag-of-words embedding (no model, no network)."""
+    vec = [0.0] * dim
+    for tok in _TOKEN.findall(text.lower()):
+        vec[int(hashlib.md5(tok.encode()).hexdigest(), 16) % dim] += 1.0
+    norm = math.sqrt(sum(v * v for v in vec)) or 1.0
+    return [v / norm for v in vec]
+
+
+def _embed(text: str) -> list[float]:
+    if os.environ.get("THREAD_RECALL_EMBED", "hashing").strip().lower() == "ollama":
+        import json
+        import urllib.request
+
+        host = os.environ.get("THREAD_RECALL_OLLAMA_HOST", "http://localhost:11434").rstrip("/")
+        model = os.environ.get("THREAD_RECALL_OLLAMA_MODEL", "nomic-embed-text")
+        req = urllib.request.Request(
+            f"{host}/api/embeddings",
+            data=json.dumps({"model": model, "prompt": text}).encode(),
+            headers={"Content-Type": "application/json"},
+        )
+        with urllib.request.urlopen(req) as resp:
+            return list(json.loads(resp.read())["embedding"])
+    return _hash_embed(text)
+
+
+def _build_memory() -> Memory:
+    return Memory(
+        os.environ.get("THREAD_RECALL_DB", "logs/recall-mem.db"),
+        mask=os.environ.get("THREAD_RECALL_MASK", "1").strip().lower() in _ON,
+        audit=os.environ.get("THREAD_RECALL_AUDIT", "0").strip().lower() in _ON,
+    )
+
+
+mcp = FastMCP("thread-recall")
+_mem = _build_memory()
+
+
+@mcp.tool
+def remember(thread_id: str, content: str, role: str = "user",
+             actor: str | None = None) -> dict[str, Any]:
+    """Store one turn of a thread's memory. PII is masked before storage.
+
+    Args:
+        thread_id: The conversation/thread this turn belongs to.
+        content: The text to remember. Masked on write if masking is enabled.
+        role: Who said it (user / assistant / system).
+        actor: Authenticated principal owning the thread. Set by the gateway;
+            do not rely on client-supplied values for isolation.
+
+    Returns:
+        The stored turn's id. The content held in memory is the masked form.
+    """
+    turn_id = _mem.remember(_key(actor, thread_id), role, content, embedding=_embed(content))
+    return {"id": turn_id, "thread_id": thread_id, "stored": True}
+
+
+@mcp.tool
+def recall(thread_id: str, query: str, k: int = 5,
+           actor: str | None = None) -> dict[str, Any]:
+    """Recall the turns most relevant to a query, scoped to one thread.
+
+    Semantic nearest-neighbour over the actor's own thread. Only this actor's
+    copy of the thread is searched; another principal's memory is unreachable.
+    """
+    key = _key(actor, thread_id)
+    hits = _mem.search(key, _embed(query), k)
+    if not hits:  # nothing embedded yet -> fall back to recency
+        hits = _mem.recent(key, k)
+    return {"count": len(hits), "results": [_view(t.as_dict()) for t in hits]}
+
+
+@mcp.tool
+def recent(thread_id: str, k: int = 10, actor: str | None = None) -> dict[str, Any]:
+    """The last k turns of the actor's thread, in chronological order."""
+    hits = _mem.recent(_key(actor, thread_id), k)
+    return {"count": len(hits), "results": [_view(t.as_dict()) for t in hits]}
+
+
+@mcp.tool
+def forget(thread_id: str, actor: str | None = None) -> dict[str, Any]:
+    """Delete the actor's copy of a thread. Returns the number of turns removed.
+
+    Only the calling principal's namespace is touched; a caller cannot wipe
+    another actor's thread even by naming the same thread_id.
+    """
+    return {"removed": _mem.forget(_key(actor, thread_id)), "thread_id": thread_id}
+
+
+def main() -> None:
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

thread_recall/store.py

@@ -0,0 +1,208 @@
+"""Governed, on-prem conversation memory for AI agents.
+
+A small store for what an agent should remember across turns: per-thread
+conversation history (recency) and optional semantic recall (nearest-neighbour
+over stored embeddings). The "governed" part is the point — memory can be
+PII-masked on write (so raw personal data never lands in the store) and every
+write can be mirrored into a tamper-evident audit log.
+
+The default backend is SQLite with embeddings kept as JSON and cosine computed
+in Python: zero dependencies, works immediately, nothing leaves the building.
+A Postgres + pgvector backend (for scale) is the next step; this module keeps
+the embedding/scoring logic backend-agnostic so it drops in cleanly.
+
+This is deliberately NOT a read path into your database — that is sql-steward's
+job, and it stays read-only. This is the write-side state store that sits next
+to it.
+"""
+from __future__ import annotations
+
+import json
+import math
+import sqlite3
+import threading
+import time
+from dataclasses import dataclass
+
+
+@dataclass
+class Turn:
+    """One remembered turn."""
+
+    id: int
+    thread_id: str
+    ts: float
+    role: str
+    content: str
+    metadata: dict | None = None
+    score: float | None = None  # set by search()
+
+    def as_dict(self) -> dict:
+        d = {"id": self.id, "thread_id": self.thread_id, "ts": self.ts,
+             "role": self.role, "content": self.content, "metadata": self.metadata}
+        if self.score is not None:
+            d["score"] = self.score
+        return d
+
+
+def _cosine(a: list[float], b: list[float]) -> float:
+    if not a or not b or len(a) != len(b):
+        return 0.0
+    dot = sum(x * y for x, y in zip(a, b))
+    na = math.sqrt(sum(x * x for x in a))
+    nb = math.sqrt(sum(y * y for y in b))
+    if na == 0.0 or nb == 0.0:
+        return 0.0
+    return dot / (na * nb)
+
+
+class Memory:
+    """Thread-scoped agent memory.
+
+    Args:
+        path: SQLite path, or ":memory:" (default).
+        mask: scrub PII from content on write via pii-veil, if installed.
+        audit: mirror every write into an agent-blackbox ledger, if installed.
+        audit_db: path for the audit ledger (default "logs/recall.db").
+    """
+
+    def __init__(self, path: str = ":memory:", *, mask: bool = False,
+                 audit: bool = False, audit_db: str = "logs/recall.db") -> None:
+        # check_same_thread=False + a lock so the store is usable from a server
+        # (e.g. the MCP server) that dispatches calls across worker threads.
+        self._conn = sqlite3.connect(path, check_same_thread=False)
+        self._conn.row_factory = sqlite3.Row
+        self._lock = threading.Lock()
+        self._init_db()
+        self._veil = _make_veil() if mask else None
+        self._ledger = _make_ledger(audit_db) if audit else None
+
+    def _init_db(self) -> None:
+        self._conn.execute(
+            """
+            CREATE TABLE IF NOT EXISTS memories (
+                id        INTEGER PRIMARY KEY AUTOINCREMENT,
+                thread_id TEXT NOT NULL,
+                ts        REAL NOT NULL,
+                role      TEXT NOT NULL,
+                content   TEXT NOT NULL,
+                metadata  TEXT,
+                embedding TEXT
+            )
+            """
+        )
+        self._conn.execute(
+            "CREATE INDEX IF NOT EXISTS idx_thread ON memories(thread_id, id)"
+        )
+        self._conn.commit()
+
+    # -- write --------------------------------------------------------------
+
+    def remember(
+        self,
+        thread_id: str,
+        role: str,
+        content: str,
+        *,
+        embedding: list[float] | None = None,
+        metadata: dict | None = None,
+    ) -> int:
+        """Store one turn. Returns its id. Content is PII-masked first if enabled."""
+        if self._veil is not None:
+            try:
+                content = self._veil.scrub_text(content)
+            except Exception:
+                pass
+        emb = json.dumps([float(x) for x in embedding]) if embedding else None
+        ts = time.time()
+        with self._lock:
+            cur = self._conn.execute(
+                "INSERT INTO memories (thread_id, ts, role, content, metadata, embedding)"
+                " VALUES (?, ?, ?, ?, ?, ?)",
+                (thread_id, ts, role, content, json.dumps(metadata) if metadata else None, emb),
+            )
+            self._conn.commit()
+        if self._ledger is not None:
+            try:
+                self._ledger.record(
+                    actor="thread-recall", action="remember", target=thread_id,
+                    meta={"role": role, "id": cur.lastrowid},
+                )
+            except Exception:
+                pass
+        return cur.lastrowid
+
+    def forget(self, thread_id: str) -> int:
+        """Delete a thread's memory. Returns rows removed."""
+        with self._lock:
+            cur = self._conn.execute("DELETE FROM memories WHERE thread_id = ?", (thread_id,))
+            self._conn.commit()
+        return cur.rowcount
+
+    # -- read ---------------------------------------------------------------
+
+    def recent(self, thread_id: str, k: int = 10) -> list[Turn]:
+        """The last k turns of a thread, in chronological order."""
+        with self._lock:
+            rows = self._conn.execute(
+                "SELECT * FROM memories WHERE thread_id = ? ORDER BY id DESC LIMIT ?",
+                (thread_id, k),
+            ).fetchall()
+        return [_row_to_turn(r) for r in reversed(rows)]
+
+    def search(self, thread_id: str, query_embedding: list[float], k: int = 5) -> list[Turn]:
+        """Semantic recall: the k turns whose embeddings are closest to the query."""
+        with self._lock:
+            rows = self._conn.execute(
+                "SELECT * FROM memories WHERE thread_id = ? AND embedding IS NOT NULL",
+                (thread_id,),
+            ).fetchall()
+        scored: list[Turn] = []
+        for r in rows:
+            turn = _row_to_turn(r)
+            turn.score = _cosine(query_embedding, json.loads(r["embedding"]))
+            scored.append(turn)
+        scored.sort(key=lambda t: t.score or 0.0, reverse=True)
+        return scored[:k]
+
+    def count(self, thread_id: str | None = None) -> int:
+        with self._lock:
+            if thread_id is None:
+                return self._conn.execute("SELECT COUNT(*) FROM memories").fetchone()[0]
+            return self._conn.execute(
+                "SELECT COUNT(*) FROM memories WHERE thread_id = ?", (thread_id,)
+            ).fetchone()[0]
+
+    def close(self) -> None:
+        self._conn.close()
+
+
+def _row_to_turn(r: sqlite3.Row) -> Turn:
+    return Turn(
+        id=r["id"], thread_id=r["thread_id"], ts=r["ts"], role=r["role"],
+        content=r["content"],
+        metadata=json.loads(r["metadata"]) if r["metadata"] else None,
+    )
+
+
+def _make_veil():
+    try:
+        from pii_veil import Veil
+
+        return Veil()
+    except Exception:
+        return None
+
+
+def _make_ledger(path: str):
+    try:
+        import os
+
+        from agent_blackbox import Ledger
+
+        parent = os.path.dirname(path)
+        if parent:
+            os.makedirs(parent, exist_ok=True)
+        return Ledger(path)
+    except Exception:
+        return None

thread_recall-0.1.0.dist-info/METADATA

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: thread-recall
+Version: 0.1.0
+Summary: Governed, on-prem conversation memory for AI agents: per-thread history and semantic recall, with optional PII masking on write and tamper-evident audit. Zero-dependency SQLite by default.
+Project-URL: Homepage, https://github.com/Pawansingh3889/thread-recall
+Project-URL: Repository, https://github.com/Pawansingh3889/thread-recall
+Project-URL: Governed Agent Stack, https://github.com/Pawansingh3889/governed-agent-stack
+Author: Pawan Singh Kapkoti
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,ai,conversation,embeddings,governance,memory,on-prem,pgvector,pii,semantic-search,sqlite
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+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: Topic :: Database
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Provides-Extra: mask
+Requires-Dist: pii-veil>=0.1; extra == 'mask'
+Provides-Extra: mcp
+Requires-Dist: fastmcp>=2.0; extra == 'mcp'
+Provides-Extra: postgres
+Requires-Dist: pgvector>=0.2; extra == 'postgres'
+Requires-Dist: psycopg[binary]>=3.1; extra == 'postgres'
+Requires-Dist: sqlalchemy>=2.0; extra == 'postgres'
+Description-Content-Type: text/markdown
+
+# thread-recall
+
+[![PyPI](https://img.shields.io/pypi/v/thread-recall)](https://pypi.org/project/thread-recall/) [![Downloads](https://static.pepy.tech/badge/thread-recall)](https://pepy.tech/projects/thread-recall)
+
+[![License](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
+[![Python](https://img.shields.io/badge/python-3.10%2B-blue)](https://www.python.org/)
+
+> Part of the [Governed Agent Stack](https://github.com/Pawansingh3889/governed-agent-stack): free, on-prem building blocks for an AI agent you can point at a real database and audit.
+
+Governed, on-prem conversation memory for AI agents. It stores what an agent should remember across turns — per-thread history and optional semantic recall — and makes that memory **governable**: PII can be masked before it is ever written, and every write can be mirrored into a tamper-evident audit log.
+
+The default backend is **SQLite with embeddings as JSON and cosine in Python**: zero dependencies, works immediately, nothing leaves the building. A Postgres + pgvector backend (for scale) is the next step; the scoring logic is backend-agnostic so it drops in cleanly.
+
+This is the **write-side** companion to [sql-steward](https://github.com/Pawansingh3889/sql-steward). sql-steward is the read-only query gateway and stays read-only; thread-recall is where agent state lives, kept separate on purpose.
+
+## Quickstart
+
+```bash
+pip install thread-recall
+thread-recall demo
+```
+
+```python
+from thread_recall import Memory
+
+mem = Memory("agent.db")                      # or ":memory:"; mask=True / audit=True optional
+
+mem.remember("thread-42", "user", "How much MRR did the pro plan make?", embedding=embed(q))
+mem.remember("thread-42", "assistant", "Pro plan MRR was 297.")
+
+mem.recent("thread-42", k=10)                 # last 10 turns, chronological
+mem.search("thread-42", embed("revenue"), k=5) # nearest turns by embedding
+```
+
+## Why it's "governed"
+
+- **PII masked on write.** `Memory(..., mask=True)` runs content through [pii-veil](https://github.com/Pawansingh3889/pii-veil) before it is stored, so raw personal data never lands in the memory store. No-op if pii-veil isn't installed.
+- **Tamper-evident audit.** `Memory(..., audit=True)` mirrors every write into an [agent-blackbox](https://github.com/Pawansingh3889/agent-blackbox) hash-chained ledger, so "what did the agent choose to remember" has a checkable answer. No-op if agent-blackbox isn't installed.
+- **On-prem by default.** SQLite file on your disk; embeddings generated by whatever local model you choose. Nothing is sent out.
+
+## API
+
+| Method | Purpose |
+|---|---|
+| `remember(thread_id, role, content, embedding=None, metadata=None)` | Store a turn (PII-masked first if enabled). Returns its id. |
+| `recent(thread_id, k=10)` | Last k turns, chronological. |
+| `search(thread_id, query_embedding, k=5)` | Semantic recall: nearest turns by cosine over stored embeddings. |
+| `forget(thread_id)` | Delete a thread's memory. |
+| `count(thread_id=None)` | Turn count for a thread, or overall. |
+
+Embeddings are supplied by the caller (generate them with any local model). thread-recall stores and scores them; it does not call out to any embedding service itself.
+
+## Roadmap
+
+- **Postgres + pgvector backend** for scale and native nearest-neighbour (the SQLite backend computes cosine in Python, fine for thread-scoped recall, not for millions of rows).
+- A thin LangGraph adapter, to use thread-recall alongside a LangGraph checkpointer.
+
+## Develop
+
+```bash
+git clone https://github.com/Pawansingh3889/thread-recall
+cd thread-recall
+pip install -e ".[dev]"
+pytest -q
+```
+
+## License
+
+MIT

thread_recall-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+thread_recall/__init__.py,sha256=j2Hcr3PdTs_rivaz16uDJtFWEC3RqjPr60c7zRW_cdA,369
+thread_recall/cli.py,sha256=2wbj4_SkS16chNqGM-T-9neODg0FMXeG6jaZBeraUuk,1662
+thread_recall/mcp_server.py,sha256=MBt4SGHiRc7CZ_auNVi_PzlarVro9hnBzwwJyiXUhBg,6099
+thread_recall/store.py,sha256=Y3OCipi3fGKMNLjuQr9Ux4E_nRz4AhsW55NrETCsIVI,7210
+thread_recall-0.1.0.dist-info/METADATA,sha256=c9CvChUxBavY20EL4vk9lbP2nY7xaQ0gUYqSZlaQqc0,5249
+thread_recall-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+thread_recall-0.1.0.dist-info/entry_points.txt,sha256=1i4QYU9zhi-BAqc82YBjQrJXhltHS_EixOmihppZWjM,107
+thread_recall-0.1.0.dist-info/licenses/LICENSE,sha256=51_xoiIIUa98JHgVsADHCPu0ReTwVG738gd08erXscM,1076
+thread_recall-0.1.0.dist-info/RECORD,,

thread_recall-0.1.0.dist-info/WHEEL

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

thread_recall-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+thread-recall = thread_recall.cli:main
+thread-recall-mcp = thread_recall.mcp_server:main

thread_recall-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pawan Singh Kapkoti
+
+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.