langgraph-goodmem 0.1.0__tar.gz

langgraph_goodmem-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,50 @@
+name: Release to PyPI
+
+on:
+  push:
+    tags:
+      - "v*"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    name: Build distribution
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          python-version: "3.10"
+
+      - name: Build sdist + wheel
+        run: uv build
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    name: Publish to PyPI
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/langgraph-goodmem
+    permissions:
+      id-token: write
+    steps:
+      - name: Download artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      - name: Publish to PyPI via Trusted Publishing
+        uses: pypa/gh-action-pypi-publish@release/v1

langgraph_goodmem-0.1.0/.gitignore

@@ -0,0 +1,36 @@
+# Build artifacts
+dist/
+build/
+*.egg-info/
+*.egg
+
+# Python bytecode
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# Tooling caches
+.mypy_cache/
+.pytest_cache/
+.ruff_cache/
+.tox/
+.coverage
+.coverage.*
+htmlcov/
+coverage.xml
+
+# Editor / OS
+.idea/
+.vscode/
+.DS_Store
+*.swp
+*~
+
+# Environment files
+.env
+.env.local

langgraph_goodmem-0.1.0/LICENSE

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

langgraph_goodmem-0.1.0/Makefile

@@ -0,0 +1,43 @@
+.PHONY: all format lint type test test_watch
+
+# Default target
+all: lint format test
+
+######################
+# TESTING AND COVERAGE
+######################
+
+TEST ?= .
+
+test:
+	uv run pytest $(TEST)
+
+test_watch:
+	uv run ptw $(TEST)
+
+######################
+# LINTING AND FORMATTING
+######################
+
+# Define a variable for Python and notebook files.
+PYTHON_FILES=.
+MYPY_CACHE=.mypy_cache
+lint format: PYTHON_FILES=.
+lint_diff format_diff: PYTHON_FILES=$(shell git diff --name-only --relative --diff-filter=d main . | grep -E '\.py$$|\.ipynb$$')
+lint_package: PYTHON_FILES=langgraph_goodmem
+lint_tests: PYTHON_FILES=tests
+lint_tests: MYPY_CACHE=.mypy_cache_test
+
+lint lint_diff lint_package lint_tests:
+	uv run ruff check .
+	[ "$(PYTHON_FILES)" = "" ] || uv run ruff format $(PYTHON_FILES) --diff
+	[ "$(PYTHON_FILES)" = "" ] || uv run ruff check --select I $(PYTHON_FILES)
+	[ "$(PYTHON_FILES)" = "" ] || mkdir -p $(MYPY_CACHE)
+	[ "$(PYTHON_FILES)" = "" ] || uv run mypy $(PYTHON_FILES) --cache-dir $(MYPY_CACHE)
+
+type:
+	mkdir -p $(MYPY_CACHE) && uv run mypy $(PYTHON_FILES) --cache-dir $(MYPY_CACHE)
+
+format format_diff:
+	uv run ruff format $(PYTHON_FILES)
+	uv run ruff check --select I --fix $(PYTHON_FILES)

langgraph_goodmem-0.1.0/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: langgraph-goodmem
+Version: 0.1.0
+Summary: LangGraph integration for GoodMem: long-term agent memory with semantic storage and retrieval.
+Project-URL: Homepage, https://github.com/PAIR-Systems-Inc/goodmem-langgraph
+Project-URL: Repository, https://github.com/PAIR-Systems-Inc/goodmem-langgraph
+Project-URL: Documentation, https://goodmem.ai/docs
+Project-URL: Issues, https://github.com/PAIR-Systems-Inc/goodmem-langgraph/issues
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,goodmem,langgraph,llm,memory,semantic-search,vector-search
+Classifier: Development Status :: 3 - Alpha
+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: <4.0.0,>=3.10.0
+Requires-Dist: httpx<1.0.0,>=0.27.0
+Requires-Dist: langchain-core<2.0.0,>=1.0.0
+Requires-Dist: pydantic<3.0.0,>=2.7.4
+Description-Content-Type: text/markdown
+
+# langgraph-goodmem
+
+[![PyPI](https://img.shields.io/pypi/v/langgraph-goodmem.svg)](https://pypi.org/project/langgraph-goodmem/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+LangGraph integration for [GoodMem](https://goodmem.ai) — long-term agent memory with semantic storage and retrieval.
+
+GoodMem is a memory layer for AI agents that handles embedding, vector search, reranking, and LLM-powered answering server-side. This package exposes GoodMem operations as LangGraph tools that can be used with any LangGraph agent or graph.
+
+## Installation
+
+```bash
+pip install langgraph-goodmem
+```
+
+Requires Python 3.10+.
+
+## Tools
+
+| Tool | Description |
+|---|---|
+| `GoodMemListEmbedders` | List available embedder models |
+| `GoodMemListSpaces` | List all spaces in your account |
+| `GoodMemGetSpace` | Fetch a specific space by ID |
+| `GoodMemCreateSpace` | Create a new space or reuse an existing one |
+| `GoodMemUpdateSpace` | Update a space's name or metadata |
+| `GoodMemDeleteSpace` | Delete a space and all of its memories |
+| `GoodMemCreateMemory` | Store text or files as memories |
+| `GoodMemListMemories` | List memories in a space |
+| `GoodMemGetMemory` | Fetch a specific memory by ID |
+| `GoodMemRetrieveMemories` | Semantic similarity search across spaces |
+| `GoodMemDeleteMemory` | Permanently delete a memory |
+
+## Quick start
+
+```python
+from langgraph_goodmem import (
+    GoodMemCreateSpace,
+    GoodMemCreateMemory,
+    GoodMemRetrieveMemories,
+)
+from langgraph.prebuilt import create_react_agent
+
+goodmem_kwargs = {
+    "goodmem_base_url": "http://localhost:8080",
+    "goodmem_api_key": "your-api-key",
+}
+
+tools = [
+    GoodMemCreateSpace(**goodmem_kwargs),
+    GoodMemCreateMemory(**goodmem_kwargs),
+    GoodMemRetrieveMemories(**goodmem_kwargs),
+]
+
+agent = create_react_agent(model="gpt-4o", tools=tools)
+```
+
+## Usage in a custom LangGraph graph
+
+```python
+from langgraph.graph import StateGraph, START, END
+from langgraph.prebuilt import ToolNode
+from langgraph_goodmem import (
+    GoodMemCreateSpace,
+    GoodMemCreateMemory,
+    GoodMemRetrieveMemories,
+)
+
+tools = [
+    GoodMemCreateSpace(**goodmem_kwargs),
+    GoodMemCreateMemory(**goodmem_kwargs),
+    GoodMemRetrieveMemories(**goodmem_kwargs),
+]
+
+tool_node = ToolNode(tools)
+```
+
+## Environment variables
+
+| Variable | Description |
+|---|---|
+| `GOODMEM_BASE_URL` | Base URL of the GoodMem API server |
+| `GOODMEM_API_KEY` | API key for authentication |
+| `GOODMEM_VERIFY_SSL` | Set to `false` to skip TLS verification for self-signed certs (default: `true`) |
+
+## Example
+
+A full ReAct agent example is in [examples/react_agent_with_memory.py](examples/react_agent_with_memory.py).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

langgraph_goodmem-0.1.0/README.md

@@ -0,0 +1,92 @@
+# langgraph-goodmem
+
+[![PyPI](https://img.shields.io/pypi/v/langgraph-goodmem.svg)](https://pypi.org/project/langgraph-goodmem/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+LangGraph integration for [GoodMem](https://goodmem.ai) — long-term agent memory with semantic storage and retrieval.
+
+GoodMem is a memory layer for AI agents that handles embedding, vector search, reranking, and LLM-powered answering server-side. This package exposes GoodMem operations as LangGraph tools that can be used with any LangGraph agent or graph.
+
+## Installation
+
+```bash
+pip install langgraph-goodmem
+```
+
+Requires Python 3.10+.
+
+## Tools
+
+| Tool | Description |
+|---|---|
+| `GoodMemListEmbedders` | List available embedder models |
+| `GoodMemListSpaces` | List all spaces in your account |
+| `GoodMemGetSpace` | Fetch a specific space by ID |
+| `GoodMemCreateSpace` | Create a new space or reuse an existing one |
+| `GoodMemUpdateSpace` | Update a space's name or metadata |
+| `GoodMemDeleteSpace` | Delete a space and all of its memories |
+| `GoodMemCreateMemory` | Store text or files as memories |
+| `GoodMemListMemories` | List memories in a space |
+| `GoodMemGetMemory` | Fetch a specific memory by ID |
+| `GoodMemRetrieveMemories` | Semantic similarity search across spaces |
+| `GoodMemDeleteMemory` | Permanently delete a memory |
+
+## Quick start
+
+```python
+from langgraph_goodmem import (
+    GoodMemCreateSpace,
+    GoodMemCreateMemory,
+    GoodMemRetrieveMemories,
+)
+from langgraph.prebuilt import create_react_agent
+
+goodmem_kwargs = {
+    "goodmem_base_url": "http://localhost:8080",
+    "goodmem_api_key": "your-api-key",
+}
+
+tools = [
+    GoodMemCreateSpace(**goodmem_kwargs),
+    GoodMemCreateMemory(**goodmem_kwargs),
+    GoodMemRetrieveMemories(**goodmem_kwargs),
+]
+
+agent = create_react_agent(model="gpt-4o", tools=tools)
+```
+
+## Usage in a custom LangGraph graph
+
+```python
+from langgraph.graph import StateGraph, START, END
+from langgraph.prebuilt import ToolNode
+from langgraph_goodmem import (
+    GoodMemCreateSpace,
+    GoodMemCreateMemory,
+    GoodMemRetrieveMemories,
+)
+
+tools = [
+    GoodMemCreateSpace(**goodmem_kwargs),
+    GoodMemCreateMemory(**goodmem_kwargs),
+    GoodMemRetrieveMemories(**goodmem_kwargs),
+]
+
+tool_node = ToolNode(tools)
+```
+
+## Environment variables
+
+| Variable | Description |
+|---|---|
+| `GOODMEM_BASE_URL` | Base URL of the GoodMem API server |
+| `GOODMEM_API_KEY` | API key for authentication |
+| `GOODMEM_VERIFY_SSL` | Set to `false` to skip TLS verification for self-signed certs (default: `true`) |
+
+## Example
+
+A full ReAct agent example is in [examples/react_agent_with_memory.py](examples/react_agent_with_memory.py).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

langgraph_goodmem-0.1.0/examples/live_smoke_test.py

@@ -0,0 +1,325 @@
+"""Live end-to-end smoke test for every langgraph-goodmem tool.
+
+Runs against a real GoodMem server. Exercises all 11 tools and every
+post-processor knob on `goodmem_retrieve_memories` (reranker, LLM,
+relevance threshold, LLM temperature, chronological resort, max results).
+
+Required environment variables:
+    GOODMEM_BASE_URL      e.g. https://localhost:8080
+    GOODMEM_API_KEY       your GoodMem API key
+
+Optional environment variables (sensible defaults shown):
+    GOODMEM_VERIFY_SSL    "true" | "false"  (default: "false")
+    GOODMEM_EMBEDDER_ID   default: 019cfd1c-c033-7517-b7de-f73941a0464b
+    GOODMEM_RERANKER_ID   default: 019cfda4-7e2f-743c-9edb-e469a97b95c6
+    GOODMEM_LLM_ID        default: 019cfd9f-0963-76f9-b069-4cde19a64ba8
+
+Run from the repo root after `pip install -e .`:
+    python examples/live_smoke_test.py
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import time
+import uuid
+from typing import Any
+
+from langgraph_goodmem import (
+    GoodMemCreateMemory,
+    GoodMemCreateSpace,
+    GoodMemDeleteMemory,
+    GoodMemDeleteSpace,
+    GoodMemGetMemory,
+    GoodMemGetSpace,
+    GoodMemListEmbedders,
+    GoodMemListMemories,
+    GoodMemListSpaces,
+    GoodMemRetrieveMemories,
+    GoodMemUpdateSpace,
+)
+
+# --- Configuration -------------------------------------------------------
+
+BASE_URL = os.environ.get("GOODMEM_BASE_URL")
+API_KEY = os.environ.get("GOODMEM_API_KEY")
+VERIFY_SSL = os.environ.get("GOODMEM_VERIFY_SSL", "false").lower() == "true"
+
+EMBEDDER_ID = os.environ.get(
+    "GOODMEM_EMBEDDER_ID", "019cfd1c-c033-7517-b7de-f73941a0464b"
+)
+RERANKER_ID = os.environ.get(
+    "GOODMEM_RERANKER_ID", "019cfda4-7e2f-743c-9edb-e469a97b95c6"
+)
+LLM_ID = os.environ.get("GOODMEM_LLM_ID", "019cfd9f-0963-76f9-b069-4cde19a64ba8")
+
+if not BASE_URL or not API_KEY:
+    sys.exit(
+        "ERROR: set GOODMEM_BASE_URL and GOODMEM_API_KEY before running this script."
+    )
+
+KW: dict[str, Any] = {
+    "goodmem_base_url": BASE_URL,
+    "goodmem_api_key": API_KEY,
+    "goodmem_verify_ssl": VERIFY_SSL,
+}
+
+# --- Helpers -------------------------------------------------------------
+
+PASS = "\033[32m✓\033[0m"
+FAIL = "\033[31m✗\033[0m"
+INFO = "\033[36m›\033[0m"
+results: list[tuple[str, bool, str]] = []
+
+
+def step(label: str) -> None:
+    print(f"\n{INFO} {label}")
+    print("─" * (len(label) + 2))
+
+
+def call(tool_name: str, tool: Any, payload: dict[str, Any]) -> dict[str, Any]:
+    """Invoke a tool, parse the JSON, mark pass/fail, and return the result."""
+    raw = tool.invoke(payload)
+    try:
+        result = json.loads(raw)
+    except json.JSONDecodeError:
+        print(f"  {FAIL} {tool_name}: non-JSON response")
+        print(f"      {raw[:400]}")
+        results.append((tool_name, False, "non-JSON response"))
+        return {}
+    ok = bool(result.get("success"))
+    icon = PASS if ok else FAIL
+    summary = result.get("error") or result.get("message") or ""
+    print(f"  {icon} {tool_name}{'  — ' + summary if summary else ''}")
+    results.append((tool_name, ok, summary))
+    return result
+
+
+def preview(label: str, value: Any, limit: int = 200) -> None:
+    text = (
+        json.dumps(value, indent=2) if isinstance(value, (dict, list)) else str(value)
+    )
+    if len(text) > limit:
+        text = text[:limit] + " …"
+    print(f"      {label}: {text}")
+
+
+# --- Run ----------------------------------------------------------------
+
+print(f"GoodMem live smoke test  →  {BASE_URL}")
+print(f"  embedder_id  = {EMBEDDER_ID}")
+print(f"  reranker_id  = {RERANKER_ID}")
+print(f"  llm_id       = {LLM_ID}")
+
+# 1. list_embedders ------------------------------------------------------
+step("1. goodmem_list_embedders")
+r = call("list_embedders", GoodMemListEmbedders(**KW), {})
+embedders = r.get("embedders", [])
+preview("count", len(embedders))
+ids = {e.get("embedderId") for e in embedders}
+if EMBEDDER_ID not in ids:
+    print(
+        f"  {FAIL} configured EMBEDDER_ID {EMBEDDER_ID} not found in server's "
+        f"embedder list — subsequent steps may fail."
+    )
+
+# 2. list_spaces (snapshot) ---------------------------------------------
+step("2. goodmem_list_spaces (before)")
+r = call("list_spaces", GoodMemListSpaces(**KW), {})
+preview("count", len(r.get("spaces", [])))
+
+# 3. create_space --------------------------------------------------------
+space_name = f"langgraph-smoke-{int(time.time())}-{uuid.uuid4().hex[:6]}"
+step(f"3. goodmem_create_space  (name={space_name})")
+r = call(
+    "create_space",
+    GoodMemCreateSpace(**KW),
+    {"name": space_name, "embedder_id": EMBEDDER_ID},
+)
+space_id = r.get("spaceId")
+if not space_id:
+    sys.exit(f"\n{FAIL} create_space returned no spaceId, aborting.")
+preview("spaceId", space_id)
+
+# 4. get_space -----------------------------------------------------------
+step("4. goodmem_get_space")
+r = call("get_space", GoodMemGetSpace(**KW), {"space_id": space_id})
+preview("space.name", r.get("space", {}).get("name"))
+
+# 5. update_space (rename) ----------------------------------------------
+new_name = space_name + "-renamed"
+step(f"5. goodmem_update_space  (rename → {new_name})")
+r = call(
+    "update_space",
+    GoodMemUpdateSpace(**KW),
+    {"space_id": space_id, "name": new_name},
+)
+preview("space.name", r.get("space", {}).get("name"))
+
+# 6. create_memory (×3, varied content) ---------------------------------
+step("6. goodmem_create_memory  (×3 varied texts)")
+texts = [
+    "LangGraph is a framework for building stateful, multi-actor agents with LLMs.",
+    "GoodMem provides server-side embedding, vector search, and reranking.",
+    "Pasta carbonara is a Roman dish made with eggs, guanciale, and pecorino.",
+]
+memory_ids: list[str] = []
+for i, text in enumerate(texts, 1):
+    r = call(
+        f"create_memory[{i}]",
+        GoodMemCreateMemory(**KW),
+        {"space_id": space_id, "text_content": text},
+    )
+    if r.get("memoryId"):
+        memory_ids.append(r["memoryId"])
+preview("created memory_ids", memory_ids)
+
+if not memory_ids:
+    sys.exit(f"\n{FAIL} no memories created, aborting.")
+
+# 7. list_memories -------------------------------------------------------
+step("7. goodmem_list_memories")
+r = call("list_memories", GoodMemListMemories(**KW), {"space_id": space_id})
+preview("count", len(r.get("memories", [])))
+
+# 8. get_memory ----------------------------------------------------------
+step(f"8. goodmem_get_memory  (memory_id={memory_ids[0]})")
+r = call("get_memory", GoodMemGetMemory(**KW), {"memory_id": memory_ids[0]})
+preview("memory.spaceId", r.get("memory", {}).get("spaceId"))
+
+# 9. retrieve_memories — variants ---------------------------------------
+print("\n--- goodmem_retrieve_memories variants ---")
+print(
+    "  (waits up to 60s for indexing on first call; the queried memories "
+    "were just created)"
+)
+
+retrieve = GoodMemRetrieveMemories(**KW)
+query = "Which framework is used for stateful multi-actor agents?"
+
+# 9a. plain
+step("9a. retrieve_memories  (plain, no postprocessor)")
+r = call(
+    "retrieve_plain",
+    retrieve,
+    {
+        "query": query,
+        "space_ids": space_id,
+        "max_results": 5,
+        "wait_for_indexing": True,
+    },
+)
+preview("totalResults", r.get("totalResults"))
+if r.get("results"):
+    preview("top relevanceScore", r["results"][0].get("relevanceScore"))
+
+# 9b. reranker only
+step("9b. retrieve_memories  (+ reranker_id)")
+r = call(
+    "retrieve_reranker",
+    retrieve,
+    {
+        "query": query,
+        "space_ids": space_id,
+        "max_results": 5,
+        "wait_for_indexing": False,
+        "reranker_id": RERANKER_ID,
+    },
+)
+preview("totalResults", r.get("totalResults"))
+
+# 9c. LLM only (expect abstractReply)
+step("9c. retrieve_memories  (+ llm_id  → abstractReply)")
+r = call(
+    "retrieve_llm",
+    retrieve,
+    {
+        "query": query,
+        "space_ids": space_id,
+        "max_results": 5,
+        "wait_for_indexing": False,
+        "llm_id": LLM_ID,
+        "llm_temperature": 0.2,
+    },
+)
+preview("totalResults", r.get("totalResults"))
+preview("abstractReply", r.get("abstractReply"), limit=400)
+
+# 9d. reranker + LLM + relevance threshold
+step(
+    "9d. retrieve_memories  (+ reranker_id + llm_id + relevance_threshold=0.1 "
+    "+ llm_temperature=0.5)"
+)
+r = call(
+    "retrieve_full",
+    retrieve,
+    {
+        "query": query,
+        "space_ids": space_id,
+        "max_results": 5,
+        "wait_for_indexing": False,
+        "reranker_id": RERANKER_ID,
+        "llm_id": LLM_ID,
+        "relevance_threshold": 0.1,
+        "llm_temperature": 0.5,
+    },
+)
+preview("totalResults", r.get("totalResults"))
+preview("abstractReply", r.get("abstractReply"), limit=400)
+
+# 9e. chronological resort
+step("9e. retrieve_memories  (+ chronological_resort=True)")
+r = call(
+    "retrieve_chrono",
+    retrieve,
+    {
+        "query": query,
+        "space_ids": space_id,
+        "max_results": 5,
+        "wait_for_indexing": False,
+        "reranker_id": RERANKER_ID,
+        "chronological_resort": True,
+    },
+)
+preview("totalResults", r.get("totalResults"))
+
+# 9f. max_results=1
+step("9f. retrieve_memories  (max_results=1)")
+r = call(
+    "retrieve_max1",
+    retrieve,
+    {
+        "query": query,
+        "space_ids": space_id,
+        "max_results": 1,
+        "wait_for_indexing": False,
+    },
+)
+preview("totalResults", r.get("totalResults"))
+
+# 10. delete_memory (one) ------------------------------------------------
+step(f"10. goodmem_delete_memory  (memory_id={memory_ids[-1]})")
+call("delete_memory", GoodMemDeleteMemory(**KW), {"memory_id": memory_ids[-1]})
+
+# 11. delete_space (cleanup) --------------------------------------------
+step(f"11. goodmem_delete_space  (space_id={space_id})")
+call("delete_space", GoodMemDeleteSpace(**KW), {"space_id": space_id})
+
+# --- Summary ------------------------------------------------------------
+
+print("\n" + "═" * 60)
+print(" SUMMARY")
+print("═" * 60)
+passed = sum(1 for _, ok, _ in results if ok)
+total = len(results)
+for name, ok, msg in results:
+    icon = PASS if ok else FAIL
+    line = f"  {icon} {name}"
+    if not ok and msg:
+        line += f"  — {msg}"
+    print(line)
+print("─" * 60)
+print(f"  {passed}/{total} passed")
+sys.exit(0 if passed == total else 1)