vaultzero 0.1.0__tar.gz

vaultzero-0.1.0/.gitignore

@@ -0,0 +1,69 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+*.lcov
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# mypy / pyre / pytype
+.mypy_cache/
+.dmypy.json
+dmypy.json
+.pyre/
+.pytype/
+
+# Ruff
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# JetBrains IDE
+.idea/

vaultzero-0.1.0/LICENSE

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

vaultzero-0.1.0/PKG-INFO

@@ -0,0 +1,236 @@
+Metadata-Version: 2.5
+Name: vaultzero
+Version: 0.1.0
+Summary: MCP server for a privacy-first agent memory vault: memories are encrypted on the client before they reach the server.
+Project-URL: Homepage, https://vaultzero.cc
+Project-URL: Documentation, https://github.com/xo0ps/VaultZero-Client#readme
+Project-URL: Issues, https://github.com/xo0ps/VaultZero-Client/issues
+Project-URL: Repository, https://github.com/xo0ps/VaultZero-Client
+Project-URL: Source, https://github.com/xo0ps/VaultZero-Client
+Author: VaultZero contributors
+License: MIT
+License-File: LICENSE
+Keywords: agent-memory,ai-agents,encryption,end-to-end-encryption,llm,long-term-memory,mcp,model-context-protocol,privacy
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: <3.14,>=3.13
+Provides-Extra: client
+Requires-Dist: cryptography>=43; extra == 'client'
+Requires-Dist: httpx>=0.28; extra == 'client'
+Requires-Dist: mcp<2,>=1.6; extra == 'client'
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.25; extra == 'dev'
+Requires-Dist: pytest>=8.3; extra == 'dev'
+Requires-Dist: ruff>=0.8; extra == 'dev'
+Provides-Extra: mcp
+Requires-Dist: cryptography>=43; extra == 'mcp'
+Requires-Dist: httpx>=0.28; extra == 'mcp'
+Requires-Dist: mcp<2,>=1.6; extra == 'mcp'
+Description-Content-Type: text/markdown
+
+# VaultZero Client
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![MCP](https://img.shields.io/badge/MCP-server-blueviolet)](https://modelcontextprotocol.io)
+[![Python 3.13](https://img.shields.io/badge/python-3.13-blue.svg)](https://www.python.org)
+
+**An MCP server that gives an AI agent long-term memory it cannot read.** VaultZero is a
+privacy-first memory vault: this package embeds and encrypts every memory on your machine
+before it is sent, so the server stores ciphertext and vectors and never holds a key.
+
+This repository is the trusted, customer-side client: the SDK, the crypto, the embedding
+adapters, and the Model Context Protocol server. It is the only code that ever sees
+plaintext or holds payload keys.
+
+> The server stores ciphertext, vector embeddings (which can be partially inverted to text),
+> scope labels, record sizes and timestamps. It cannot read your memories, but it is not
+> "a server that knows nothing". See the [trust model](#trust-model) below.
+
+## MCP server
+
+Two tools, so an agent can remember across sessions and recall by meaning rather than by key:
+
+| Tool | What it does |
+|---|---|
+| `remember_fact` | Encrypts a fact locally and stores it under a scope you permit. |
+| `recall_context` | Embeds the query, retrieves the nearest ciphertext envelopes, verifies each one, and decrypts locally. |
+
+The model never chooses a tenant, a user, or a key, and cannot grant itself a scope.
+Remembered text comes back explicitly framed as untrusted data, so a stored instruction
+cannot become a command.
+
+### Install
+
+Requires Python 3.13.
+
+```bash
+pip install "vaultzero[mcp]"    # or: uv tool install "vaultzero[mcp]"
+```
+
+### Configure a client
+
+```json
+{
+  "mcpServers": {
+    "vaultzero": {
+      "command": "uvx",
+      "args": ["--from", "vaultzero[mcp]", "vaultzero-mcp"],
+      "env": {
+        "VZ_BASE_URL": "https://api.vaultzero.cc",
+        "VZ_CREDENTIAL": "<your 64-hex-character bearer credential>",
+        "VZ_KEY_STORE_PATH": "~/.vaultzero/keys.json",
+        "VZ_EMBEDDING_BASE_URL": "https://<your-embeddings-endpoint>/v1"
+      }
+    }
+  }
+}
+```
+
+`VZ_BASE_URL` and `VZ_CREDENTIAL` are required. The other three are strongly recommended and
+are described under [Configuration](#configuration).
+
+### Docker
+
+```bash
+docker build -t vaultzero-mcp .
+docker run -i --rm \
+  -e VZ_BASE_URL=https://api.vaultzero.cc \
+  -e VZ_CREDENTIAL=... \
+  -v vaultzero-keys:/keys -e VZ_KEY_STORE_PATH=/keys/keys.json \
+  vaultzero-mcp
+```
+
+`-i` without `-t`: stdio transport needs a raw stdin, not a TTY. The image runs as UID 10001
+and ships no pip.
+
+## Configuration
+
+| Variable | Required | Purpose |
+|---|---|---|
+| `VZ_BASE_URL` | yes | Bare HTTPS origin of the VaultZero API. |
+| `VZ_CREDENTIAL` | yes | Bearer credential. Secret. |
+| `VZ_KEY_STORE_PATH` | recommended | Where payload keys persist. **Without it keys live in memory and every memory becomes unreadable when the process exits.** |
+| `VZ_EMBEDDING_BASE_URL` | recommended | OpenAI-compatible embeddings endpoint, ideally customer-controlled. Without it a hashing test provider is used, which gives no meaningful retrieval. |
+| `VZ_EMBEDDING_API_KEY` | no | Bearer token for the embeddings endpoint. Secret. |
+| `VZ_EMBEDDING_SPACE`, `_MODEL`, `_REVISION`, `_PREPROCESSING` | no | Pin the embedding space. Changing any of them changes the vectors and makes existing memories unsearchable. |
+| `VZ_PERMITTED_SCOPES` | no | Comma-separated scopes this process may use. Defaults to `preferences,work,financial,medical`. |
+| `VZ_RETENTION_CHOICES` | no | Retention values offered to the model. Defaults to `30d,90d,365d`. Add `forever` only for a credential with a retention grant. |
+
+## Trust model
+
+What the server can and cannot see, stated precisely:
+
+- **It cannot** read a memory: payloads are AES-256-GCM ciphertext, and keys exist only in
+  this process's key store.
+- **It can** see vector embeddings, which are partially invertible to text. Treat the
+  embeddings endpoint and the API origin as part of your data path.
+- **It can** see the shape of your data: scope labels, record sizes, timestamps, and
+  identifiers.
+
+Memory contents are only as safe as the key store. Losing every copy of a key makes its
+memories unrecoverable by design; production hosts should use `FileKeyStore` or a
+KMS/keychain adapter, not the in-memory default.
+
+## Contents
+
+- **SDK** (`vaultzero.client.sdk`): HTTP lifecycle, retries, key lookup, and local
+  decryption.
+- **Crypto** (`vaultzero.client.crypto`): AES-256-GCM envelope encryption with authenticated
+  associated data.
+- **Embeddings** (`vaultzero.client.embeddings`): embedding-provider adapters with pinned
+  embedding-space configuration.
+- **MCP host** (`vaultzero.client.mcp_server`): a Model Context Protocol server exposing
+  `remember_fact` and `recall_context` tools to an agent.
+
+## Layout
+
+```
+vaultzero/client/      SDK, MCP adapter, crypto, embedding providers
+tests/unit/            golden vectors and unit tests for the client
+```
+
+## Installing the SDK
+
+Requires Python 3.13.
+
+```bash
+pip install "vaultzero[client]"
+```
+
+The `[client]` extra pulls `cryptography`, `httpx`, and `mcp`; it installs the
+`vaultzero-mcp` console script and makes `vaultzero.client.sdk.VaultZeroClient` importable.
+
+## SDK usage
+
+```python
+import asyncio
+
+from vaultzero.client.embeddings import EmbeddingSpace, OpenAICompatibleEmbeddings
+from vaultzero.client.sdk import FileKeyStore, VaultZeroClient
+
+
+async def main() -> None:
+    client = VaultZeroClient(
+        base_url="https://api.example.com",
+        credential="<64-hex-character bearer secret>",
+        key_store=FileKeyStore("~/.vaultzero/keys.json"),
+        embedding_provider=OpenAICompatibleEmbeddings(
+            space=EmbeddingSpace(
+                space_id="my-space-v1",
+                model="text-embedding-3-small",
+                revision="1",
+                preprocessing="nfc-strip-v1",
+            ),
+            base_url="https://<customer-controlled-embeddings>",
+            api_key=None,
+        ),
+    )
+    memory_id = await client.remember_fact("prefers oat milk in coffee", scope="preferences")
+    results = await client.recall_context("coffee milk", scopes=["preferences"])
+    await client.delete(memory_id)
+    await client.aclose()
+
+
+asyncio.run(main())
+```
+
+Keys: one active key per scope, resolved only from the bound subject's trusted key store and
+reused across writes until rotated. Losing every copy of a key makes its memories
+unrecoverable, so production hosts must use a persistent store (`FileKeyStore` or a
+KMS/keychain adapter).
+
+## MCP host
+
+Run the MCP host (the trusted process that holds keys and sees plaintext):
+
+```bash
+VZ_BASE_URL=https://... VZ_CREDENTIAL=<secret> VZ_KEY_STORE_PATH=~/.vaultzero/keys.json \
+VZ_EMBEDDING_BASE_URL=https://<customer-controlled-embeddings> vaultzero-mcp
+```
+
+Without `VZ_KEY_STORE_PATH` keys live in memory and every memory becomes unreadable when the
+process exits. Optional: `VZ_PERMITTED_SCOPES`, `VZ_RETENTION_CHOICES` (add `forever` only
+for credentials with a retention grant), `VZ_SERVERLESS_TOKEN` for IAM-protected endpoints.
+
+## Security model
+
+- **Local encryption**: AES-256-GCM; the associated data binds every envelope to its exact
+  tenant, user, agent, subject epoch, memory id, scope, entity token, key id, embedding
+  space, and expiration.
+- **No plaintext to the server**: the SDK embeds and encrypts before sending anything.
+- **Integrity on recall**: every recalled envelope is re-checked against the authenticated
+  request context before decryption; tampered or mismatched envelopes raise `IntegrityError`.
+- **No redirects**: the HTTP client never forwards credentials to a redirect target.
+
+Golden vectors live in `tests/unit/golden_vectors.json`; any other SDK implementation must
+reproduce them.
+
+## Tests
+
+```bash
+uv run --python .venv/bin/python -m pytest
+```

vaultzero-0.1.0/README.md

@@ -0,0 +1,202 @@
+# VaultZero Client
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![MCP](https://img.shields.io/badge/MCP-server-blueviolet)](https://modelcontextprotocol.io)
+[![Python 3.13](https://img.shields.io/badge/python-3.13-blue.svg)](https://www.python.org)
+
+**An MCP server that gives an AI agent long-term memory it cannot read.** VaultZero is a
+privacy-first memory vault: this package embeds and encrypts every memory on your machine
+before it is sent, so the server stores ciphertext and vectors and never holds a key.
+
+This repository is the trusted, customer-side client: the SDK, the crypto, the embedding
+adapters, and the Model Context Protocol server. It is the only code that ever sees
+plaintext or holds payload keys.
+
+> The server stores ciphertext, vector embeddings (which can be partially inverted to text),
+> scope labels, record sizes and timestamps. It cannot read your memories, but it is not
+> "a server that knows nothing". See the [trust model](#trust-model) below.
+
+## MCP server
+
+Two tools, so an agent can remember across sessions and recall by meaning rather than by key:
+
+| Tool | What it does |
+|---|---|
+| `remember_fact` | Encrypts a fact locally and stores it under a scope you permit. |
+| `recall_context` | Embeds the query, retrieves the nearest ciphertext envelopes, verifies each one, and decrypts locally. |
+
+The model never chooses a tenant, a user, or a key, and cannot grant itself a scope.
+Remembered text comes back explicitly framed as untrusted data, so a stored instruction
+cannot become a command.
+
+### Install
+
+Requires Python 3.13.
+
+```bash
+pip install "vaultzero[mcp]"    # or: uv tool install "vaultzero[mcp]"
+```
+
+### Configure a client
+
+```json
+{
+  "mcpServers": {
+    "vaultzero": {
+      "command": "uvx",
+      "args": ["--from", "vaultzero[mcp]", "vaultzero-mcp"],
+      "env": {
+        "VZ_BASE_URL": "https://api.vaultzero.cc",
+        "VZ_CREDENTIAL": "<your 64-hex-character bearer credential>",
+        "VZ_KEY_STORE_PATH": "~/.vaultzero/keys.json",
+        "VZ_EMBEDDING_BASE_URL": "https://<your-embeddings-endpoint>/v1"
+      }
+    }
+  }
+}
+```
+
+`VZ_BASE_URL` and `VZ_CREDENTIAL` are required. The other three are strongly recommended and
+are described under [Configuration](#configuration).
+
+### Docker
+
+```bash
+docker build -t vaultzero-mcp .
+docker run -i --rm \
+  -e VZ_BASE_URL=https://api.vaultzero.cc \
+  -e VZ_CREDENTIAL=... \
+  -v vaultzero-keys:/keys -e VZ_KEY_STORE_PATH=/keys/keys.json \
+  vaultzero-mcp
+```
+
+`-i` without `-t`: stdio transport needs a raw stdin, not a TTY. The image runs as UID 10001
+and ships no pip.
+
+## Configuration
+
+| Variable | Required | Purpose |
+|---|---|---|
+| `VZ_BASE_URL` | yes | Bare HTTPS origin of the VaultZero API. |
+| `VZ_CREDENTIAL` | yes | Bearer credential. Secret. |
+| `VZ_KEY_STORE_PATH` | recommended | Where payload keys persist. **Without it keys live in memory and every memory becomes unreadable when the process exits.** |
+| `VZ_EMBEDDING_BASE_URL` | recommended | OpenAI-compatible embeddings endpoint, ideally customer-controlled. Without it a hashing test provider is used, which gives no meaningful retrieval. |
+| `VZ_EMBEDDING_API_KEY` | no | Bearer token for the embeddings endpoint. Secret. |
+| `VZ_EMBEDDING_SPACE`, `_MODEL`, `_REVISION`, `_PREPROCESSING` | no | Pin the embedding space. Changing any of them changes the vectors and makes existing memories unsearchable. |
+| `VZ_PERMITTED_SCOPES` | no | Comma-separated scopes this process may use. Defaults to `preferences,work,financial,medical`. |
+| `VZ_RETENTION_CHOICES` | no | Retention values offered to the model. Defaults to `30d,90d,365d`. Add `forever` only for a credential with a retention grant. |
+
+## Trust model
+
+What the server can and cannot see, stated precisely:
+
+- **It cannot** read a memory: payloads are AES-256-GCM ciphertext, and keys exist only in
+  this process's key store.
+- **It can** see vector embeddings, which are partially invertible to text. Treat the
+  embeddings endpoint and the API origin as part of your data path.
+- **It can** see the shape of your data: scope labels, record sizes, timestamps, and
+  identifiers.
+
+Memory contents are only as safe as the key store. Losing every copy of a key makes its
+memories unrecoverable by design; production hosts should use `FileKeyStore` or a
+KMS/keychain adapter, not the in-memory default.
+
+## Contents
+
+- **SDK** (`vaultzero.client.sdk`): HTTP lifecycle, retries, key lookup, and local
+  decryption.
+- **Crypto** (`vaultzero.client.crypto`): AES-256-GCM envelope encryption with authenticated
+  associated data.
+- **Embeddings** (`vaultzero.client.embeddings`): embedding-provider adapters with pinned
+  embedding-space configuration.
+- **MCP host** (`vaultzero.client.mcp_server`): a Model Context Protocol server exposing
+  `remember_fact` and `recall_context` tools to an agent.
+
+## Layout
+
+```
+vaultzero/client/      SDK, MCP adapter, crypto, embedding providers
+tests/unit/            golden vectors and unit tests for the client
+```
+
+## Installing the SDK
+
+Requires Python 3.13.
+
+```bash
+pip install "vaultzero[client]"
+```
+
+The `[client]` extra pulls `cryptography`, `httpx`, and `mcp`; it installs the
+`vaultzero-mcp` console script and makes `vaultzero.client.sdk.VaultZeroClient` importable.
+
+## SDK usage
+
+```python
+import asyncio
+
+from vaultzero.client.embeddings import EmbeddingSpace, OpenAICompatibleEmbeddings
+from vaultzero.client.sdk import FileKeyStore, VaultZeroClient
+
+
+async def main() -> None:
+    client = VaultZeroClient(
+        base_url="https://api.example.com",
+        credential="<64-hex-character bearer secret>",
+        key_store=FileKeyStore("~/.vaultzero/keys.json"),
+        embedding_provider=OpenAICompatibleEmbeddings(
+            space=EmbeddingSpace(
+                space_id="my-space-v1",
+                model="text-embedding-3-small",
+                revision="1",
+                preprocessing="nfc-strip-v1",
+            ),
+            base_url="https://<customer-controlled-embeddings>",
+            api_key=None,
+        ),
+    )
+    memory_id = await client.remember_fact("prefers oat milk in coffee", scope="preferences")
+    results = await client.recall_context("coffee milk", scopes=["preferences"])
+    await client.delete(memory_id)
+    await client.aclose()
+
+
+asyncio.run(main())
+```
+
+Keys: one active key per scope, resolved only from the bound subject's trusted key store and
+reused across writes until rotated. Losing every copy of a key makes its memories
+unrecoverable, so production hosts must use a persistent store (`FileKeyStore` or a
+KMS/keychain adapter).
+
+## MCP host
+
+Run the MCP host (the trusted process that holds keys and sees plaintext):
+
+```bash
+VZ_BASE_URL=https://... VZ_CREDENTIAL=<secret> VZ_KEY_STORE_PATH=~/.vaultzero/keys.json \
+VZ_EMBEDDING_BASE_URL=https://<customer-controlled-embeddings> vaultzero-mcp
+```
+
+Without `VZ_KEY_STORE_PATH` keys live in memory and every memory becomes unreadable when the
+process exits. Optional: `VZ_PERMITTED_SCOPES`, `VZ_RETENTION_CHOICES` (add `forever` only
+for credentials with a retention grant), `VZ_SERVERLESS_TOKEN` for IAM-protected endpoints.
+
+## Security model
+
+- **Local encryption**: AES-256-GCM; the associated data binds every envelope to its exact
+  tenant, user, agent, subject epoch, memory id, scope, entity token, key id, embedding
+  space, and expiration.
+- **No plaintext to the server**: the SDK embeds and encrypts before sending anything.
+- **Integrity on recall**: every recalled envelope is re-checked against the authenticated
+  request context before decryption; tampered or mismatched envelopes raise `IntegrityError`.
+- **No redirects**: the HTTP client never forwards credentials to a redirect target.
+
+Golden vectors live in `tests/unit/golden_vectors.json`; any other SDK implementation must
+reproduce them.
+
+## Tests
+
+```bash
+uv run --python .venv/bin/python -m pytest
+```

vaultzero-0.1.0/pyproject.toml

@@ -0,0 +1,96 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "vaultzero"
+version = "0.1.0"
+# This string is what MCP directories show next to the listing, so it names the thing a
+# prospective user is looking for (an MCP server) before the architecture behind it.
+description = "MCP server for a privacy-first agent memory vault: memories are encrypted on the client before they reach the server."
+readme = "README.md"
+requires-python = ">=3.13,<3.14"
+license = { text = "MIT" }
+authors = [{ name = "VaultZero contributors" }]
+keywords = [
+    "mcp",
+    "model-context-protocol",
+    "ai-agents",
+    "agent-memory",
+    "long-term-memory",
+    "privacy",
+    "encryption",
+    "end-to-end-encryption",
+    "llm",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Security :: Cryptography",
+]
+dependencies = []
+
+[project.optional-dependencies]
+# Trusted customer-side SDK and MCP host process.
+client = [
+    "cryptography>=43",
+    "httpx>=0.28",
+    "mcp>=1.6,<2",
+]
+# For `pip install vaultzero[mcp]`: everything the `vaultzero-mcp` console script needs, so a
+# directory's install snippet is a single line rather than an understanding of this repo's
+# extra layout.
+mcp = [
+    "vaultzero[client]",
+]
+dev = [
+    "pytest>=8.3",
+    "pytest-asyncio>=0.25",
+    "ruff>=0.8",
+]
+
+[project.scripts]
+vaultzero-mcp = "vaultzero.client.mcp_server:main"
+
+[project.urls]
+Homepage = "https://vaultzero.cc"
+Documentation = "https://github.com/xo0ps/VaultZero-Client#readme"
+Issues = "https://github.com/xo0ps/VaultZero-Client/issues"
+Repository = "https://github.com/xo0ps/VaultZero-Client"
+Source = "https://github.com/xo0ps/VaultZero-Client"
+
+[tool.uv]
+# Resolve from public PyPI only, whatever a developer's global uv configuration points at. A
+# corporate or private index would otherwise leak into uv.lock and make the project
+# unresolvable for everyone else (403 on a package the lock references). The global config is
+# untouched.
+[[tool.uv.index]]
+name = "pypi"
+url = "https://pypi.org/simple"
+default = true
+
+[tool.hatch.build.targets.wheel]
+packages = ["vaultzero"]
+
+[tool.hatch.build.targets.sdist]
+include = ["vaultzero", "tests", "README.md", "LICENSE"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "session"
+asyncio_default_test_loop_scope = "session"
+
+[tool.ruff]
+line-length = 100
+target-version = "py313"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "B", "UP", "S", "ASYNC"]
+ignore = ["S101", "S608"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**" = ["S105", "S106", "S311", "S603", "S607"]

vaultzero-0.1.0/tests/unit/golden_vectors.json

@@ -0,0 +1,24 @@
+{
+  "vectors": [
+    {
+      "aad": "[\"vaultzero\",1,\"A256GCM\",\"00000000-0000-0000-0000-000000000001\",\"00000000-0000-0000-0000-000000000002\",\"00000000-0000-0000-0000-000000000003\",\"00000000-0000-0000-0000-000000000004\",\"00000000-0000-0000-0000-000000000005\",\"preferences\",\"00000000-0000-0000-0000-000000000006\",\"test-key-1\",\"test-hashing-v1\",1999999999]",
+      "ciphertext_b64": "IG26f6CL4m3oIuPkw8kIAeK/6UCVAyvq73WBpeT+XMeYg17P+gQ2",
+      "fields": {
+        "agent_id": "00000000-0000-0000-0000-000000000003",
+        "embedding_space": "test-hashing-v1",
+        "entity_token": "00000000-0000-0000-0000-000000000006",
+        "expires_at_epoch": 1999999999,
+        "key_id": "test-key-1",
+        "memory_id": "00000000-0000-0000-0000-000000000005",
+        "scope": "preferences",
+        "subject_epoch": "00000000-0000-0000-0000-000000000004",
+        "tenant_id": "00000000-0000-0000-0000-000000000001",
+        "user_id": "00000000-0000-0000-0000-000000000002"
+      },
+      "key_b64": "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8=",
+      "name": "preferences-scope-expiring",
+      "nonce_b64": "AAECAwQFBgcICQoL",
+      "plaintext_b64": "Z29sZGVuIHZlY3RvciBwbGFpbnRleHQ="
+    }
+  ]
+}