writ-mcp 0.1.0__tar.gz

writ_mcp-0.1.0/LICENSE

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

writ_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: writ-mcp
+Version: 0.1.0
+Summary: Writ MCP server — commit-time policy checks for AI agents (ALLOW/DENY/STEP_UP + audit receipts)
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/AvenueDAdmin/pywrit
+Project-URL: Repository, https://github.com/AvenueDAdmin/pywrit/tree/main/mcp
+Project-URL: Documentation, https://withwrit.com/docs
+Keywords: ai-agents,mcp,policy,audit-log,guardrails
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp<2,>=1.0
+Requires-Dist: httpx>=0.27
+Dynamic: license-file
+
+# writ-mcp
+
+The [Writ](https://withwrit.com) gate as an MCP server. Give any MCP-compatible
+agent commit-time control: the agent calls Writ **before** a consequential
+write, gets back `ALLOW`, `DENY`, or `STEP_UP`, and every outcome creates an
+audit receipt.
+
+## Install
+
+```bash
+pip install writ-mcp
+```
+
+Requires Python 3.9+. Installs the `writ-mcp` command (stdio transport).
+
+## Configure
+
+```bash
+export WRIT_API_KEY="writ_..."        # required; get one free: POST /v1/keys with an email
+export WRIT_SPONSOR_TOKEN="..."       # only for sponsor tools (grant, revoke, reinstate)
+# export WRIT_BASE_URL="..."          # default: https://api.withwrit.com
+```
+
+## Add to your agent
+
+Claude Code:
+
+```bash
+claude mcp add writ --env WRIT_API_KEY="$WRIT_API_KEY" -- writ-mcp
+```
+
+Claude Desktop (`claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "writ": {
+      "command": "writ-mcp",
+      "env": { "WRIT_API_KEY": "writ_..." }
+    }
+  }
+}
+```
+
+Any MCP client (generic stdio config):
+
+```json
+{
+  "command": "writ-mcp",
+  "env": {
+    "WRIT_API_KEY": "writ_...",
+    "WRIT_SPONSOR_TOKEN": "writ_sp_..."
+  }
+}
+```
+
+Hermes (NousResearch/hermes-agent) catalog entry — once published, this
+package is installable from the `optional-mcps` catalog:
+
+```bash
+hermes mcp install writ
+```
+
+## The check-before-write loop
+
+The tool descriptions teach the agent this flow, but the short version:
+
+1. `writ_check(sponsor_id, agent_id, verb, target, purpose)` — before the write.
+2. `ALLOW` → you get a 90-second `authToken` bound to that exact write.
+3. `writ_verify_token(auth_token, verb, target, purpose)` — immediately before
+   executing, to prove the authorization still matches what you're doing.
+4. `DENY` → do not proceed. `STEP_UP` → a human sponsor approves
+   (via `writ_grant` or the dashboard), then check again.
+
+## Tools
+
+| Tool | Who | What |
+|---|---|---|
+| `writ_check` | agent | Decision + 90s purpose-bound token |
+| `writ_verify_token` | agent | Commit-time token verification |
+| `writ_grant` | sponsor | Approve a STEP_UP (one-time grant) |
+| `writ_revoke` / `writ_reinstate` | sponsor | Kill switch on/off for a principal |
+| `writ_receipts` | agent | Audit trail of decisions |
+| `writ_policy` | agent | Tenant verb policy |
+| `writ_sandbox` | anyone | Free 90-second demo grant, no key needed |
+
+Try it with no key: `writ_sandbox` → `writ_check` with `verb="demo_write"`.
+
+## Source
+
+Public repo: [AvenueDAdmin/pywrit](https://github.com/AvenueDAdmin/pywrit) (`mcp/`
+directory). License: MIT.

writ_mcp-0.1.0/README.md

@@ -0,0 +1,92 @@
+# writ-mcp
+
+The [Writ](https://withwrit.com) gate as an MCP server. Give any MCP-compatible
+agent commit-time control: the agent calls Writ **before** a consequential
+write, gets back `ALLOW`, `DENY`, or `STEP_UP`, and every outcome creates an
+audit receipt.
+
+## Install
+
+```bash
+pip install writ-mcp
+```
+
+Requires Python 3.9+. Installs the `writ-mcp` command (stdio transport).
+
+## Configure
+
+```bash
+export WRIT_API_KEY="writ_..."        # required; get one free: POST /v1/keys with an email
+export WRIT_SPONSOR_TOKEN="..."       # only for sponsor tools (grant, revoke, reinstate)
+# export WRIT_BASE_URL="..."          # default: https://api.withwrit.com
+```
+
+## Add to your agent
+
+Claude Code:
+
+```bash
+claude mcp add writ --env WRIT_API_KEY="$WRIT_API_KEY" -- writ-mcp
+```
+
+Claude Desktop (`claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "writ": {
+      "command": "writ-mcp",
+      "env": { "WRIT_API_KEY": "writ_..." }
+    }
+  }
+}
+```
+
+Any MCP client (generic stdio config):
+
+```json
+{
+  "command": "writ-mcp",
+  "env": {
+    "WRIT_API_KEY": "writ_...",
+    "WRIT_SPONSOR_TOKEN": "writ_sp_..."
+  }
+}
+```
+
+Hermes (NousResearch/hermes-agent) catalog entry — once published, this
+package is installable from the `optional-mcps` catalog:
+
+```bash
+hermes mcp install writ
+```
+
+## The check-before-write loop
+
+The tool descriptions teach the agent this flow, but the short version:
+
+1. `writ_check(sponsor_id, agent_id, verb, target, purpose)` — before the write.
+2. `ALLOW` → you get a 90-second `authToken` bound to that exact write.
+3. `writ_verify_token(auth_token, verb, target, purpose)` — immediately before
+   executing, to prove the authorization still matches what you're doing.
+4. `DENY` → do not proceed. `STEP_UP` → a human sponsor approves
+   (via `writ_grant` or the dashboard), then check again.
+
+## Tools
+
+| Tool | Who | What |
+|---|---|---|
+| `writ_check` | agent | Decision + 90s purpose-bound token |
+| `writ_verify_token` | agent | Commit-time token verification |
+| `writ_grant` | sponsor | Approve a STEP_UP (one-time grant) |
+| `writ_revoke` / `writ_reinstate` | sponsor | Kill switch on/off for a principal |
+| `writ_receipts` | agent | Audit trail of decisions |
+| `writ_policy` | agent | Tenant verb policy |
+| `writ_sandbox` | anyone | Free 90-second demo grant, no key needed |
+
+Try it with no key: `writ_sandbox` → `writ_check` with `verb="demo_write"`.
+
+## Source
+
+Public repo: [AvenueDAdmin/pywrit](https://github.com/AvenueDAdmin/pywrit) (`mcp/`
+directory). License: MIT.

writ_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "writ-mcp"
+version = "0.1.0"
+description = "Writ MCP server — commit-time policy checks for AI agents (ALLOW/DENY/STEP_UP + audit receipts)"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+dependencies = [
+    "mcp>=1.0,<2",
+    "httpx>=0.27",
+]
+keywords = ["ai-agents", "mcp", "policy", "audit-log", "guardrails"]
+
+[project.urls]
+Homepage = "https://github.com/AvenueDAdmin/pywrit"
+Repository = "https://github.com/AvenueDAdmin/pywrit/tree/main/mcp"
+Documentation = "https://withwrit.com/docs"
+
+[project.scripts]
+writ-mcp = "writ_mcp.server:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

writ_mcp-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

writ_mcp-0.1.0/src/writ_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""writ-mcp — the Writ gate as an MCP server for AI agents."""
+
+__version__ = "0.1.0"

writ_mcp-0.1.0/src/writ_mcp/server.py

@@ -0,0 +1,229 @@
+"""Writ MCP server — commit-time policy checks for AI agents, as MCP tools.
+
+An agent (or any MCP client) calls `writ_check` BEFORE performing a
+consequential write. Writ answers ALLOW, DENY, or STEP_UP, and every outcome
+creates an audit receipt. On ALLOW the agent also receives a 90-second
+purpose-bound auth token; it must pass `writ_verify_token` against the
+intended verb/target/purpose immediately before executing the write.
+
+Configuration (environment variables):
+  WRIT_BASE_URL      Gate base URL. Defaults to the hosted Writ gate
+                     (https://api.withwrit.com).
+  WRIT_API_KEY       API key (starts with writ_). Get one free: POST /v1/keys
+                     with an email (see the Writ docs quickstart).
+  WRIT_SPONSOR_TOKEN Tenant sponsor token (writ_sp_..., shown once at key
+                     issuance). Only needed for sponsor tools
+                     (writ_grant, writ_revoke, writ_reinstate).
+
+Run:  writ-mcp                  (stdio transport, installed via pip)
+      python -m writ_mcp.server (same, without the console script)
+"""
+
+import json
+import os
+import urllib.parse
+
+import httpx
+from mcp.server.fastmcp import FastMCP
+
+BASE_URL = os.environ.get(
+    "WRIT_BASE_URL",
+    "https://api.withwrit.com",
+).rstrip("/")
+API_KEY = os.environ.get("WRIT_API_KEY", "").strip()
+SPONSOR_TOKEN = os.environ.get("WRIT_SPONSOR_TOKEN", "").strip()
+
+mcp = FastMCP("writ")
+
+
+class WritError(Exception):
+    def __init__(self, status, payload):
+        self.status = status
+        self.payload = payload
+        super().__init__(f"Writ API error {status}: {payload}")
+
+
+def _call(method, path, body=None, credential="", timeout=20.0):
+    """Low-level gate call. Returns parsed JSON, raises WritError on failure."""
+    url = BASE_URL + path
+    headers = {"Content-Type": "application/json"}
+    if credential:
+        headers["Authorization"] = f"Bearer {credential}"
+    with httpx.Client(timeout=timeout) as client:
+        resp = client.request(method, url, headers=headers,
+                              content=json.dumps(body) if body is not None else None)
+    try:
+        payload = resp.json()
+    except ValueError:
+        payload = {"raw": resp.text[:500]}
+    if resp.status_code >= 400:
+        raise WritError(resp.status_code, payload)
+    return payload
+
+
+def _key_call(method, path, body=None):
+    if not API_KEY:
+        raise WritError(0, {"error": "WRIT_API_KEY is not set. Get a free key: POST /v1/keys with an email."})
+    return _call(method, path, body, credential=API_KEY)
+
+
+def _sponsor_call(method, path, body=None):
+    if not SPONSOR_TOKEN:
+        raise WritError(0, {"error": "WRIT_SPONSOR_TOKEN is not set. Sponsor tools need the tenant's sponsor token."})
+    return _call(method, path, body, credential=SPONSOR_TOKEN)
+
+
+def _fmt(result):
+    return json.dumps(result, indent=2)
+
+
+@mcp.tool()
+def writ_check(sponsor_id: str, agent_id: str, verb: str, target: str, purpose: str) -> str:
+    """Ask Writ whether an action may proceed. CALL THIS BEFORE any consequential write.
+
+    A consequential write is anything hard to undo: sending money or messages,
+    changing access or identity records, deleting data, calling an external API
+    that acts in the world.
+
+    Args:
+        sponsor_id: The human sponsor accountable for this action (e.g. a user id or email).
+        agent_id:   The agent or workflow performing the action.
+        verb:       What is being done (e.g. "verify_human", "send_payment").
+        target:     What it acts on (e.g. "benefit-case-123").
+        purpose:    Why, in plain words. Be specific — the approval is bound to this purpose.
+
+    Returns a decision:
+      ALLOW   — proceed. You get an authToken valid 90 seconds, bound to this
+                exact sponsor/agent/verb/target/purpose. Call writ_verify_token
+                against the intended write immediately before executing it.
+      DENY    — do NOT perform the action. Explain the receipt reason to the user.
+      STEP_UP — a human sponsor must approve first. Tell the user what needs
+                approval; they can approve via writ_grant (or the dashboard),
+                then call writ_check again.
+    Every outcome creates an audit receipt with a receiptId.
+    """
+    try:
+        return _fmt(_key_call("POST", "/v1/check", {
+            "sponsorId": sponsor_id, "agentId": agent_id,
+            "verb": verb, "target": target, "purpose": purpose,
+        }))
+    except WritError as e:
+        return _fmt({"error": str(e), "status": e.status, "detail": e.payload})
+
+
+@mcp.tool()
+def writ_verify_token(auth_token: str, verb: str, target: str, purpose: str) -> str:
+    """Verify a Writ auth token against the write you are about to execute.
+
+    Call this IMMEDIATELY before executing an ALLOWed write, with the exact
+    verb/target/purpose you intend. If valid is false — expired, tampered, or
+    bound to a different purpose — do NOT execute the write; call writ_check again.
+
+    This is the commit-time enforcement: the check authorizes, the token proves
+    the authorization still matches what you are actually doing.
+    """
+    try:
+        return _fmt(_key_call("POST", "/v1/tokens/verify", {
+            "token": auth_token, "verb": verb, "target": target, "purpose": purpose,
+        }))
+    except WritError as e:
+        return _fmt({"error": str(e), "status": e.status, "detail": e.payload})
+
+
+@mcp.tool()
+def writ_grant(sponsor_id: str, agent_id: str, verb: str, target: str, purpose: str,
+              ttl_seconds: int = 90) -> str:
+    """SPONSOR ONLY. Mint a one-time grant approving a specific action.
+
+    Use this when writ_check returned STEP_UP and the human sponsor approves.
+    The grant is single-use: the next writ_check consumes it and returns ALLOW.
+    The grant is scoped to your tenant. Requires WRIT_SPONSOR_TOKEN.
+    """
+    try:
+        return _fmt(_sponsor_call("POST", "/v1/grants", {
+            "sponsorId": sponsor_id, "agentId": agent_id,
+            "verb": verb, "target": target, "purpose": purpose,
+            "ttlSeconds": ttl_seconds,
+        }))
+    except WritError as e:
+        return _fmt({"error": str(e), "status": e.status, "detail": e.payload})
+
+
+@mcp.tool()
+def writ_revoke(sponsor_id: str, agent_id: str) -> str:
+    """SPONSOR ONLY. Kill switch: immediately deny all future checks for this principal.
+
+    Revocation overrides live grants and tenant policy. Use when a principal is
+    compromised, misbehaving, or its task is done. Scoped to your tenant.
+    Requires WRIT_SPONSOR_TOKEN.
+    """
+    try:
+        return _fmt(_sponsor_call("POST", "/v1/revoke", {
+            "sponsorId": sponsor_id, "agentId": agent_id,
+        }))
+    except WritError as e:
+        return _fmt({"error": str(e), "status": e.status, "detail": e.payload})
+
+
+@mcp.tool()
+def writ_reinstate(sponsor_id: str, agent_id: str) -> str:
+    """SPONSOR ONLY. Undo writ_revoke: the principal is evaluated by policy again.
+
+    Scoped to your tenant. Requires WRIT_SPONSOR_TOKEN.
+    """
+    try:
+        return _fmt(_sponsor_call("POST", "/v1/reinstate", {
+            "sponsorId": sponsor_id, "agentId": agent_id,
+        }))
+    except WritError as e:
+        return _fmt({"error": str(e), "status": e.status, "detail": e.payload})
+
+
+@mcp.tool()
+def writ_receipts(limit: int = 10) -> str:
+    """List recent decision receipts (audit trail). Newest first."""
+    try:
+        data = _key_call("GET", "/v1/receipts")
+        receipts = data.get("receipts", data)
+        if isinstance(receipts, list):
+            receipts = receipts[: max(1, limit)]
+        return _fmt(receipts)
+    except WritError as e:
+        return _fmt({"error": str(e), "status": e.status, "detail": e.payload})
+
+
+@mcp.tool()
+def writ_policy() -> str:
+    """Read the tenant's verb policy: which verbs allow, deny, require a grant, or step up."""
+    try:
+        return _fmt(_key_call("GET", "/v1/policy"))
+    except WritError as e:
+        return _fmt({"error": str(e), "status": e.status, "detail": e.payload})
+
+
+@mcp.tool()
+def writ_sandbox(sponsor_id: str, agent_id: str, target: str, purpose: str) -> str:
+    """Get a free 90-second sandbox grant for a demo write. No API key needed.
+
+    Issues a live grant for verb "demo_write" on a target starting with "demo-",
+    then runs writ_check so you get back an ALLOW decision plus auth token to
+    practice the verify-before-write flow end to end.
+    """
+    try:
+        grant = _call("POST", "/v1/sandbox", {
+            "sponsorId": sponsor_id, "agentId": agent_id,
+            "verb": "demo_write", "target": target, "purpose": purpose,
+        })
+        return _fmt({"sandboxGrant": grant,
+                     "note": 'Now call writ_check with verb "demo_write" to get your ALLOW + authToken.'})
+    except WritError as e:
+        return _fmt({"error": str(e), "status": e.status, "detail": e.payload})
+
+
+def main():
+    """Console-script entry point: run the MCP server over stdio."""
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

writ_mcp-0.1.0/src/writ_mcp.egg-info/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: writ-mcp
+Version: 0.1.0
+Summary: Writ MCP server — commit-time policy checks for AI agents (ALLOW/DENY/STEP_UP + audit receipts)
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/AvenueDAdmin/pywrit
+Project-URL: Repository, https://github.com/AvenueDAdmin/pywrit/tree/main/mcp
+Project-URL: Documentation, https://withwrit.com/docs
+Keywords: ai-agents,mcp,policy,audit-log,guardrails
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp<2,>=1.0
+Requires-Dist: httpx>=0.27
+Dynamic: license-file
+
+# writ-mcp
+
+The [Writ](https://withwrit.com) gate as an MCP server. Give any MCP-compatible
+agent commit-time control: the agent calls Writ **before** a consequential
+write, gets back `ALLOW`, `DENY`, or `STEP_UP`, and every outcome creates an
+audit receipt.
+
+## Install
+
+```bash
+pip install writ-mcp
+```
+
+Requires Python 3.9+. Installs the `writ-mcp` command (stdio transport).
+
+## Configure
+
+```bash
+export WRIT_API_KEY="writ_..."        # required; get one free: POST /v1/keys with an email
+export WRIT_SPONSOR_TOKEN="..."       # only for sponsor tools (grant, revoke, reinstate)
+# export WRIT_BASE_URL="..."          # default: https://api.withwrit.com
+```
+
+## Add to your agent
+
+Claude Code:
+
+```bash
+claude mcp add writ --env WRIT_API_KEY="$WRIT_API_KEY" -- writ-mcp
+```
+
+Claude Desktop (`claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "writ": {
+      "command": "writ-mcp",
+      "env": { "WRIT_API_KEY": "writ_..." }
+    }
+  }
+}
+```
+
+Any MCP client (generic stdio config):
+
+```json
+{
+  "command": "writ-mcp",
+  "env": {
+    "WRIT_API_KEY": "writ_...",
+    "WRIT_SPONSOR_TOKEN": "writ_sp_..."
+  }
+}
+```
+
+Hermes (NousResearch/hermes-agent) catalog entry — once published, this
+package is installable from the `optional-mcps` catalog:
+
+```bash
+hermes mcp install writ
+```
+
+## The check-before-write loop
+
+The tool descriptions teach the agent this flow, but the short version:
+
+1. `writ_check(sponsor_id, agent_id, verb, target, purpose)` — before the write.
+2. `ALLOW` → you get a 90-second `authToken` bound to that exact write.
+3. `writ_verify_token(auth_token, verb, target, purpose)` — immediately before
+   executing, to prove the authorization still matches what you're doing.
+4. `DENY` → do not proceed. `STEP_UP` → a human sponsor approves
+   (via `writ_grant` or the dashboard), then check again.
+
+## Tools
+
+| Tool | Who | What |
+|---|---|---|
+| `writ_check` | agent | Decision + 90s purpose-bound token |
+| `writ_verify_token` | agent | Commit-time token verification |
+| `writ_grant` | sponsor | Approve a STEP_UP (one-time grant) |
+| `writ_revoke` / `writ_reinstate` | sponsor | Kill switch on/off for a principal |
+| `writ_receipts` | agent | Audit trail of decisions |
+| `writ_policy` | agent | Tenant verb policy |
+| `writ_sandbox` | anyone | Free 90-second demo grant, no key needed |
+
+Try it with no key: `writ_sandbox` → `writ_check` with `verb="demo_write"`.
+
+## Source
+
+Public repo: [AvenueDAdmin/pywrit](https://github.com/AvenueDAdmin/pywrit) (`mcp/`
+directory). License: MIT.

writ_mcp-0.1.0/src/writ_mcp.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/writ_mcp/__init__.py
+src/writ_mcp/server.py
+src/writ_mcp.egg-info/PKG-INFO
+src/writ_mcp.egg-info/SOURCES.txt
+src/writ_mcp.egg-info/dependency_links.txt
+src/writ_mcp.egg-info/entry_points.txt
+src/writ_mcp.egg-info/requires.txt
+src/writ_mcp.egg-info/top_level.txt
+tests/test_server.py

writ_mcp-0.1.0/src/writ_mcp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

writ_mcp-0.1.0/src/writ_mcp.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+writ-mcp = writ_mcp.server:main

writ_mcp-0.1.0/src/writ_mcp.egg-info/requires.txt

@@ -0,0 +1,2 @@
+mcp<2,>=1.0
+httpx>=0.27

writ_mcp-0.1.0/src/writ_mcp.egg-info/top_level.txt

@@ -0,0 +1 @@
+writ_mcp

writ_mcp-0.1.0/tests/test_server.py

@@ -0,0 +1,36 @@
+"""writ-mcp package tests — import-time checks only, no network."""
+
+import asyncio
+
+import writ_mcp
+from writ_mcp import server
+
+EXPECTED_TOOLS = {
+    "writ_check",
+    "writ_verify_token",
+    "writ_grant",
+    "writ_revoke",
+    "writ_reinstate",
+    "writ_receipts",
+    "writ_policy",
+    "writ_sandbox",
+}
+
+
+def test_version():
+    assert writ_mcp.__version__ == "0.1.0"
+
+
+def test_public_base_url_default():
+    # The public package must never default to an internal endpoint.
+    assert server.BASE_URL == "https://api.withwrit.com"
+    assert "lambda-url" not in server.BASE_URL
+
+
+def test_all_tools_registered():
+    tools = asyncio.run(server.mcp.list_tools())
+    assert {t.name for t in tools} == EXPECTED_TOOLS
+
+
+def test_main_entrypoint_exists():
+    assert callable(server.main)