agent-utils-swarm 0.1.0__tar.gz

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

@@ -0,0 +1,40 @@
+name: release
+
+on:
+  push:
+    tags: ["v*"]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Check tag matches version
+        run: |
+          version=$(python -c 'import tomllib; print(tomllib.load(open("pyproject.toml", "rb"))["project"]["version"])')
+          if [ "v$version" != "$GITHUB_REF_NAME" ]; then
+            echo "tag $GITHUB_REF_NAME does not match pyproject version $version"
+            exit 1
+          fi
+      - run: python -m pip install build
+      - run: python -m build
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

agent_utils_swarm-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+build/
+dist/
+*.egg-info/
+.venv/
+.DS_Store

agent_utils_swarm-0.1.0/LICENSE

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

agent_utils_swarm-0.1.0/PKG-INFO

@@ -0,0 +1,130 @@
+Metadata-Version: 2.5
+Name: agent-utils-swarm
+Version: 0.1.0
+Summary: Thin client for the agent_utils Swarm MCP server - memory, locks, task board, pub/sub, idempotency and webhook inboxes for AI agents. One account spans both agent_utils servers.
+Project-URL: Homepage, https://agent-utils.ai
+Project-URL: Repository, https://github.com/agent-utils/agent-utils-swarm-py
+Author-email: AI Cortex LLC <support@agent-utils.ai>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent-memory,agent-utils,ai-agents,claude,distributed-locks,idempotency,mcp,model-context-protocol,multi-agent,pubsub,task-queue,webhooks
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# agent-utils-swarm
+
+Thin Python client for the **agent_utils Swarm** server - stateful coordination for AI agents over MCP: memory, locks, task board, pub/sub, idempotency and webhook inboxes.
+
+This is a client for a hosted commercial service ([agent-utils.ai](https://agent-utils.ai)), not the service itself. Zero dependencies (standard library only). Install name `agent-utils-swarm`; import `agent_utils.swarm` (a namespace package).
+
+## Install
+
+```bash
+pip install agent-utils-swarm
+```
+
+## Quickstart
+
+```python
+import json, os
+from agent_utils.swarm import AgentUtilsSwarm
+
+# Any secret works as a token; the first call auto-provisions a free trial.
+swarm = AgentUtilsSwarm(token=os.environ["AGENT_UTILS_TOKEN"])
+
+swarm.put_memory("project", "status", json.dumps({"phase": "review"}))
+
+# Hand work out through the task board; any agent can claim it atomically.
+swarm.create_task(board="launch", title="Write release notes")
+claimed = swarm.claim_task(board="launch", agent_name="writer")
+
+# Tell the rest of the swarm, and wait (long-poll) for replies.
+swarm.publish(topic="launch", body="release notes in progress", sender="writer")
+news = swarm.read_topic(topics=["launch"], wait_seconds=20)
+```
+
+## API
+
+**Memory** - persistent key-value memory
+- `get_memory(namespace, key)`
+- `put_memory(namespace, key, value_json, months?, tags?, priority?)`
+- `replace_memory(namespace, key, value_json, priority?, summary?, tags_to_add?, tags_to_delete?)`
+- `extend_memory_ttl(namespace, key, months)`
+- `delete_memory(namespace, key)`
+- `list_keys(namespace)`
+- `list_namespaces()`
+- `search_by_tag(tag)`
+- `top_memories(namespace, n)`
+
+**Mutex** - distributed locks
+- `acquire_lock(resource_id, agent_name, ttl_seconds?, reason?)`
+- `release_lock(resource_id, kill_token)`
+- `extend_lock(resource_id, kill_token, additional_ttl_seconds)`
+- `check_lock(resource_id)`
+- `list_active_locks()`
+
+**Task board** - shared work queue with atomic claims, leases and dependencies
+- `create_task(board, title, description?, priority?, depends_on?, tags?, memory?, created_by?)`
+- `list_tasks(board, status?, owner?, tag?, ready_only?, limit?)`
+- `get_task(board, task_id)`
+- `claim_task(board, agent_name, task_id?, tag?, lease_seconds?)`
+- `complete_task(board, task_id, agent_name, result?, memory?)`
+- `release_task(board, task_id, agent_name)`
+- `update_task(board, task_id, ...)`
+- `delete_task(board, task_id)`
+- `list_boards()`
+- `renew_board(board, months?)`
+- `delete_board(board)`
+
+**Pub/sub** - topics agents publish to and long-poll
+- `publish(topic, body, ttl_seconds?, sender?)`
+- `read_topic(topics, after?, limit?, wait_seconds?)`
+- `renew_message(topic, seq, ttl_seconds?)`
+- `list_topics()`
+- `delete_topic(topic, delete_token)`
+
+**Idempotency** - exactly-once operations
+- `acquire_key(key, operation, agent_name)`
+- `complete_key / fail_key / check_key`
+- `create_operation_rule / list_operation_rules / delete_operation_rule / cleanup_operation_rules`
+
+**Webhook inbox** - temporary webhook receivers
+- `create_inbox(...)`
+- `poll_inbox(...)`
+- `list_inboxes()`
+- `delete_inbox(...)`
+- `configure_inbox_settings(...)`
+- `cleanup_expired()`
+
+**Account** (on both servers) - `get_account`, `list_api_keys`, `create_api_key`, `revoke_api_key`, `list_payments`, `settle_balance`, `submit_feature_request`, `submit_exit_feedback`, `delete_account`
+
+- `call(name, args)` - call any tool by name
+
+Python methods use the tool names; TypeScript methods are their camelCase forms (`claim_task` -> `claimTask`). Memory has typed parameters; the other services take keyword arguments (Python) or an args object (TypeScript) that are passed straight through as the tool's arguments.
+
+Every response carries a `_meta` envelope with `account_status`, `op_cost`, and
+`credits_remaining`. The canonical, always-current reference is the server's
+[llms.txt](https://mcp.agent-utils.ai/llms.txt) (per service: `/docs/<service>`).
+
+Endpoint: `https://mcp.agent-utils.ai/swarm` (staging: `STAGING_ENDPOINT`, `https://mcp-staging.agent-utils.ai/swarm`).
+
+## One token, both servers
+
+agent_utils is two MCP servers on one account: **swarm** (this one) and **extensions** (math, units). The same token works on both and draws from one credit pool. See the [agent-utils hub](https://github.com/agent-utils/agent-utils) for the full platform, and the TypeScript client [`@agent-utils/swarm`](https://github.com/agent-utils/agent-utils-swarm-ts).
+
+## Pricing
+
+1 credit = $0.00001. Trial: 1,000 credits, no card. Activation: $5 -> 500,000-credit limit. Terms: [mcp.agent-utils.ai/legal.txt](https://mcp.agent-utils.ai/legal.txt).
+
+## Contact
+
+Questions, bugs or account issues: support@agent-utils.ai
+
+## License
+
+MIT. The hosted agent_utils service is a separate commercial product and is not open-source.

agent_utils_swarm-0.1.0/README.md

@@ -0,0 +1,112 @@
+# agent-utils-swarm
+
+Thin Python client for the **agent_utils Swarm** server - stateful coordination for AI agents over MCP: memory, locks, task board, pub/sub, idempotency and webhook inboxes.
+
+This is a client for a hosted commercial service ([agent-utils.ai](https://agent-utils.ai)), not the service itself. Zero dependencies (standard library only). Install name `agent-utils-swarm`; import `agent_utils.swarm` (a namespace package).
+
+## Install
+
+```bash
+pip install agent-utils-swarm
+```
+
+## Quickstart
+
+```python
+import json, os
+from agent_utils.swarm import AgentUtilsSwarm
+
+# Any secret works as a token; the first call auto-provisions a free trial.
+swarm = AgentUtilsSwarm(token=os.environ["AGENT_UTILS_TOKEN"])
+
+swarm.put_memory("project", "status", json.dumps({"phase": "review"}))
+
+# Hand work out through the task board; any agent can claim it atomically.
+swarm.create_task(board="launch", title="Write release notes")
+claimed = swarm.claim_task(board="launch", agent_name="writer")
+
+# Tell the rest of the swarm, and wait (long-poll) for replies.
+swarm.publish(topic="launch", body="release notes in progress", sender="writer")
+news = swarm.read_topic(topics=["launch"], wait_seconds=20)
+```
+
+## API
+
+**Memory** - persistent key-value memory
+- `get_memory(namespace, key)`
+- `put_memory(namespace, key, value_json, months?, tags?, priority?)`
+- `replace_memory(namespace, key, value_json, priority?, summary?, tags_to_add?, tags_to_delete?)`
+- `extend_memory_ttl(namespace, key, months)`
+- `delete_memory(namespace, key)`
+- `list_keys(namespace)`
+- `list_namespaces()`
+- `search_by_tag(tag)`
+- `top_memories(namespace, n)`
+
+**Mutex** - distributed locks
+- `acquire_lock(resource_id, agent_name, ttl_seconds?, reason?)`
+- `release_lock(resource_id, kill_token)`
+- `extend_lock(resource_id, kill_token, additional_ttl_seconds)`
+- `check_lock(resource_id)`
+- `list_active_locks()`
+
+**Task board** - shared work queue with atomic claims, leases and dependencies
+- `create_task(board, title, description?, priority?, depends_on?, tags?, memory?, created_by?)`
+- `list_tasks(board, status?, owner?, tag?, ready_only?, limit?)`
+- `get_task(board, task_id)`
+- `claim_task(board, agent_name, task_id?, tag?, lease_seconds?)`
+- `complete_task(board, task_id, agent_name, result?, memory?)`
+- `release_task(board, task_id, agent_name)`
+- `update_task(board, task_id, ...)`
+- `delete_task(board, task_id)`
+- `list_boards()`
+- `renew_board(board, months?)`
+- `delete_board(board)`
+
+**Pub/sub** - topics agents publish to and long-poll
+- `publish(topic, body, ttl_seconds?, sender?)`
+- `read_topic(topics, after?, limit?, wait_seconds?)`
+- `renew_message(topic, seq, ttl_seconds?)`
+- `list_topics()`
+- `delete_topic(topic, delete_token)`
+
+**Idempotency** - exactly-once operations
+- `acquire_key(key, operation, agent_name)`
+- `complete_key / fail_key / check_key`
+- `create_operation_rule / list_operation_rules / delete_operation_rule / cleanup_operation_rules`
+
+**Webhook inbox** - temporary webhook receivers
+- `create_inbox(...)`
+- `poll_inbox(...)`
+- `list_inboxes()`
+- `delete_inbox(...)`
+- `configure_inbox_settings(...)`
+- `cleanup_expired()`
+
+**Account** (on both servers) - `get_account`, `list_api_keys`, `create_api_key`, `revoke_api_key`, `list_payments`, `settle_balance`, `submit_feature_request`, `submit_exit_feedback`, `delete_account`
+
+- `call(name, args)` - call any tool by name
+
+Python methods use the tool names; TypeScript methods are their camelCase forms (`claim_task` -> `claimTask`). Memory has typed parameters; the other services take keyword arguments (Python) or an args object (TypeScript) that are passed straight through as the tool's arguments.
+
+Every response carries a `_meta` envelope with `account_status`, `op_cost`, and
+`credits_remaining`. The canonical, always-current reference is the server's
+[llms.txt](https://mcp.agent-utils.ai/llms.txt) (per service: `/docs/<service>`).
+
+Endpoint: `https://mcp.agent-utils.ai/swarm` (staging: `STAGING_ENDPOINT`, `https://mcp-staging.agent-utils.ai/swarm`).
+
+## One token, both servers
+
+agent_utils is two MCP servers on one account: **swarm** (this one) and **extensions** (math, units). The same token works on both and draws from one credit pool. See the [agent-utils hub](https://github.com/agent-utils/agent-utils) for the full platform, and the TypeScript client [`@agent-utils/swarm`](https://github.com/agent-utils/agent-utils-swarm-ts).
+
+## Pricing
+
+1 credit = $0.00001. Trial: 1,000 credits, no card. Activation: $5 -> 500,000-credit limit. Terms: [mcp.agent-utils.ai/legal.txt](https://mcp.agent-utils.ai/legal.txt).
+
+## Contact
+
+Questions, bugs or account issues: support@agent-utils.ai
+
+## License
+
+MIT. The hosted agent_utils service is a separate commercial product and is not open-source.

agent_utils_swarm-0.1.0/llms-install.md

@@ -0,0 +1,103 @@
+# Install - instructions for an AI agent
+
+**Nothing to clone, build, or run.** agent_utils Swarm is a *hosted* MCP server at
+`https://mcp.agent-utils.ai/swarm`. Installing it means pointing your MCP client at that URL with a
+Bearer token. There is no signup, no dashboard, no API-key request, and no payment card.
+
+If you are looking for a package to launch as a local stdio server, stop - this is a remote
+(Streamable HTTP) server. The npm/PyPI package below is an optional convenience client, not
+the server.
+
+## 1. Generate a token
+
+The token *is* the account. Any sufficiently random secret works, and the first call
+auto-provisions a free trial (1,000 credits).
+
+```bash
+TOKEN=sk_$(openssl rand -hex 32)
+echo "$TOKEN"   # save this - losing it means losing the account and its data
+```
+
+## 2. Register the server
+
+**Claude Code** - one command:
+
+```bash
+claude mcp add --scope user --transport http agent-utils-swarm https://mcp.agent-utils.ai/swarm \
+  --header "Authorization: Bearer $TOKEN"
+```
+
+**Cline / Cursor / Windsurf** - add to the MCP settings JSON:
+
+```json
+{
+  "mcpServers": {
+    "agent-utils-swarm": {
+      "url": "https://mcp.agent-utils.ai/swarm",
+      "headers": { "Authorization": "Bearer sk_REPLACE_WITH_YOUR_TOKEN" }
+    }
+  }
+}
+```
+
+## 3. Verify before spending anything
+
+`tools/list` needs **no authentication**, so reachability can be confirmed before the first
+billed call:
+
+```bash
+curl -s -X POST https://mcp.agent-utils.ai/swarm \
+  -H 'Content-Type: application/json' \
+  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
+```
+
+Expect 53 tools: memory, mutex, task board, pub/sub, idempotency and webhook inbox, plus the 9 shared account tools
+(`get_account`, `create_api_key`, `list_api_keys`, `revoke_api_key`, `list_payments`,
+`settle_balance`, `submit_feature_request`, `submit_exit_feedback`).
+
+## 4. Confirm the account
+
+`get_account` is free - it creates the trial account and returns its state:
+
+```bash
+curl -s -X POST https://mcp.agent-utils.ai/swarm \
+  -H "Authorization: Bearer $TOKEN" -H 'Content-Type: application/json' \
+  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_account","arguments":{}}}'
+```
+
+A successful response means installation is complete.
+
+## Optional: the client library
+
+```bash
+pip install agent-utils-swarm
+```
+
+See `README.md` in this repo for the API.
+
+## One token, both servers
+
+agent_utils is two MCP servers: **swarm** (`https://mcp.agent-utils.ai/swarm` - memory, mutex,
+task board, pub/sub, idempotency, webhook inbox) and **extensions**
+(`https://mcp.agent-utils.ai/extensions` - math, units). The same token works on
+both and draws from a single credit pool. To add the other one, repeat step 2 with
+`agent-utils-extensions`, `https://mcp.agent-utils.ai/extensions`, and **the same token**.
+
+## Cost
+
+1 credit = $0.00001. Trial: 1,000 credits, no card. A one-time $5 activation raises the limit
+to 500,000 credits for the whole account. `get_account`, `settle_balance`, and
+`submit_exit_feedback` are free. Terms: <https://mcp.agent-utils.ai/legal.txt>.
+
+## Troubleshooting
+
+- **HTTP 401** - the `Authorization` header is missing or malformed. It must be exactly
+  `Bearer <token>`.
+- **HTTP 403 "error code: 1010"** - Cloudflare rejected your HTTP client's default
+  User-Agent (Python's `urllib` is blocked). Send any descriptive `User-Agent` header.
+- **No tools listed / 404** - you are probably POSTing to the wrong path. The endpoint is
+  `/swarm`, not the domain root or `/mcp`.
+- **"Key already exists" on a write** - services distinguish create from update. Check the
+  tool description returned by `tools/list`; it names the right tool.
+- **Authoritative reference** - the server's own spec is always current:
+  <https://mcp.agent-utils.ai/llms.txt>.

agent_utils_swarm-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "agent-utils-swarm"
+version = "0.1.0"
+description = "Thin client for the agent_utils Swarm MCP server - memory, locks, task board, pub/sub, idempotency and webhook inboxes for AI agents. One account spans both agent_utils servers."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{ name = "AI Cortex LLC", email = "support@agent-utils.ai" }]
+keywords = ["mcp", "model-context-protocol", "ai-agents", "agent-memory", "distributed-locks", "task-queue", "pubsub", "idempotency", "webhooks", "multi-agent", "claude", "agent-utils"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://agent-utils.ai"
+Repository = "https://github.com/agent-utils/agent-utils-swarm-py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/agent_utils"]

agent_utils_swarm-0.1.0/src/agent_utils/swarm/__init__.py

@@ -0,0 +1,287 @@
+# SPDX-License-Identifier: MIT
+"""Thin MCP-over-HTTP client for the hosted agent_utils Swarm server.
+
+Swarm is the stateful half of agent_utils: memory, mutex, task board, pub/sub,
+idempotency and webhook inbox, all on one endpoint.
+
+This is a client, not the service - see https://agent-utils.ai.
+Zero dependencies: standard library only.
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.request
+from typing import Any
+
+DEFAULT_ENDPOINT = "https://mcp.agent-utils.ai/swarm"
+STAGING_ENDPOINT = "https://mcp-staging.agent-utils.ai/swarm"
+USER_AGENT = "agent-utils-swarm-py/0.1.0"
+
+__all__ = ["AgentUtilsSwarm", "DEFAULT_ENDPOINT", "STAGING_ENDPOINT"]
+
+
+class AgentUtilsSwarm:
+    """Client for the agent_utils Swarm MCP server.
+
+    The same token works on both agent_utils servers (swarm and extensions) and
+    draws from one credit pool. Any secret works as a token - the first call
+    auto-provisions a free trial (no card). See https://agent-utils.ai.
+    """
+
+    def __init__(self, token: str, endpoint: str = DEFAULT_ENDPOINT) -> None:
+        self._token = token
+        self._endpoint = endpoint
+        self._id = 0
+
+    def call(self, name: str, arguments: dict[str, Any] | None = None) -> Any:
+        """Call any MCP tool by name and return its result."""
+        self._id += 1
+        payload = json.dumps(
+            {
+                "jsonrpc": "2.0",
+                "id": self._id,
+                "method": "tools/call",
+                "params": {"name": name, "arguments": arguments or {}},
+            }
+        ).encode()
+        req = urllib.request.Request(
+            self._endpoint,
+            data=payload,
+            method="POST",
+            headers={
+                "Authorization": f"Bearer {self._token}",
+                "Content-Type": "application/json",
+                # Cloudflare rejects urllib's default User-Agent (error 1010).
+                "User-Agent": USER_AGENT,
+            },
+        )
+        try:
+            with urllib.request.urlopen(req) as resp:
+                body = json.loads(resp.read())
+        except urllib.error.HTTPError as exc:  # pragma: no cover - network error path
+            raise RuntimeError(f"agent_utils HTTP {exc.code}: {exc.read().decode()}") from exc
+        if isinstance(body, dict) and body.get("error"):
+            raise RuntimeError(f"agent_utils: {body['error'].get('message', 'unknown error')}")
+        return body.get("result") if isinstance(body, dict) else body
+
+    # --- memory ---------------------------------------------------------------
+
+    def get_memory(self, namespace: str, key: str) -> Any:
+        return self.call("get_memory", {"namespace": namespace, "key": key})
+
+    def put_memory(
+        self,
+        namespace: str,
+        key: str,
+        value_json: str,
+        months: int | None = None,
+        tags: list[str] | None = None,
+        priority: int | None = None,
+    ) -> Any:
+        args: dict[str, Any] = {"namespace": namespace, "key": key, "value_json": value_json}
+        if months is not None:
+            args["months"] = months
+        if tags is not None:
+            args["tags"] = tags
+        if priority is not None:
+            args["priority"] = priority
+        return self.call("put_memory", args)
+
+    def replace_memory(
+        self,
+        namespace: str,
+        key: str,
+        value_json: str,
+        priority: int | None = None,
+        summary: str | None = None,
+        tags_to_add: list[str] | None = None,
+        tags_to_delete: list[str] | None = None,
+    ) -> Any:
+        """Update an existing entry.
+
+        Errors if the key does not exist - use :meth:`put_memory` to create.
+        Tags are managed explicitly; each tag operation is charged whether or
+        not the tag was already present.
+        """
+        args: dict[str, Any] = {"namespace": namespace, "key": key, "value_json": value_json}
+        if priority is not None:
+            args["priority"] = priority
+        if summary is not None:
+            args["summary"] = summary
+        if tags_to_add is not None:
+            args["tags_to_add"] = tags_to_add
+        if tags_to_delete is not None:
+            args["tags_to_delete"] = tags_to_delete
+        return self.call("replace_memory", args)
+
+    def extend_memory_ttl(self, namespace: str, key: str, months: int) -> Any:
+        """Add `months` to an existing entry's expiry.
+
+        Bills kb-months at the current stored size. Errors if the key does not
+        exist or has already expired.
+        """
+        return self.call(
+            "extend_memory_ttl", {"namespace": namespace, "key": key, "months": months}
+        )
+
+    def delete_memory(self, namespace: str, key: str) -> Any:
+        return self.call("delete_memory", {"namespace": namespace, "key": key})
+
+    def list_keys(self, namespace: str) -> Any:
+        return self.call("list_keys", {"namespace": namespace})
+
+    def list_namespaces(self) -> Any:
+        return self.call("list_namespaces", {})
+
+    def search_by_tag(self, tag: str) -> Any:
+        return self.call("search_by_tag", {"tag": tag})
+
+    def top_memories(self, namespace: str, n: int) -> Any:
+        return self.call("top_memories", {"namespace": namespace, "n": n})
+
+    # --- mutex ----------------------------------------------------------------
+
+    def acquire_lock(self, **kwargs: Any) -> Any:
+        return self.call("acquire_lock", kwargs)
+
+    def release_lock(self, **kwargs: Any) -> Any:
+        return self.call("release_lock", kwargs)
+
+    def extend_lock(self, **kwargs: Any) -> Any:
+        return self.call("extend_lock", kwargs)
+
+    def check_lock(self, **kwargs: Any) -> Any:
+        return self.call("check_lock", kwargs)
+
+    def list_active_locks(self, **kwargs: Any) -> Any:
+        return self.call("list_active_locks", kwargs)
+
+    # --- task board -----------------------------------------------------------
+
+    def create_task(self, **kwargs: Any) -> Any:
+        return self.call("create_task", kwargs)
+
+    def get_task(self, **kwargs: Any) -> Any:
+        return self.call("get_task", kwargs)
+
+    def list_tasks(self, **kwargs: Any) -> Any:
+        return self.call("list_tasks", kwargs)
+
+    def update_task(self, **kwargs: Any) -> Any:
+        return self.call("update_task", kwargs)
+
+    def claim_task(self, **kwargs: Any) -> Any:
+        return self.call("claim_task", kwargs)
+
+    def complete_task(self, **kwargs: Any) -> Any:
+        return self.call("complete_task", kwargs)
+
+    def release_task(self, **kwargs: Any) -> Any:
+        return self.call("release_task", kwargs)
+
+    def delete_task(self, **kwargs: Any) -> Any:
+        return self.call("delete_task", kwargs)
+
+    def list_boards(self, **kwargs: Any) -> Any:
+        return self.call("list_boards", kwargs)
+
+    def renew_board(self, **kwargs: Any) -> Any:
+        return self.call("renew_board", kwargs)
+
+    def delete_board(self, **kwargs: Any) -> Any:
+        return self.call("delete_board", kwargs)
+
+    # --- pub/sub --------------------------------------------------------------
+
+    def publish(self, **kwargs: Any) -> Any:
+        return self.call("publish", kwargs)
+
+    def read_topic(self, **kwargs: Any) -> Any:
+        """Read messages; pass `wait_seconds` (max 20) to long-poll."""
+        return self.call("read_topic", kwargs)
+
+    def renew_message(self, **kwargs: Any) -> Any:
+        return self.call("renew_message", kwargs)
+
+    def list_topics(self, **kwargs: Any) -> Any:
+        return self.call("list_topics", kwargs)
+
+    def delete_topic(self, **kwargs: Any) -> Any:
+        return self.call("delete_topic", kwargs)
+
+    # --- idempotency ----------------------------------------------------------
+
+    def list_operation_rules(self, **kwargs: Any) -> Any:
+        return self.call("list_operation_rules", kwargs)
+
+    def create_operation_rule(self, **kwargs: Any) -> Any:
+        return self.call("create_operation_rule", kwargs)
+
+    def delete_operation_rule(self, **kwargs: Any) -> Any:
+        return self.call("delete_operation_rule", kwargs)
+
+    def acquire_key(self, **kwargs: Any) -> Any:
+        return self.call("acquire_key", kwargs)
+
+    def complete_key(self, **kwargs: Any) -> Any:
+        return self.call("complete_key", kwargs)
+
+    def fail_key(self, **kwargs: Any) -> Any:
+        return self.call("fail_key", kwargs)
+
+    def check_key(self, **kwargs: Any) -> Any:
+        return self.call("check_key", kwargs)
+
+    def cleanup_operation_rules(self, **kwargs: Any) -> Any:
+        return self.call("cleanup_operation_rules", kwargs)
+
+    # --- webhook inbox --------------------------------------------------------
+
+    def create_inbox(self, **kwargs: Any) -> Any:
+        return self.call("create_inbox", kwargs)
+
+    def poll_inbox(self, **kwargs: Any) -> Any:
+        return self.call("poll_inbox", kwargs)
+
+    def list_inboxes(self, **kwargs: Any) -> Any:
+        return self.call("list_inboxes", kwargs)
+
+    def delete_inbox(self, **kwargs: Any) -> Any:
+        return self.call("delete_inbox", kwargs)
+
+    def configure_inbox_settings(self, **kwargs: Any) -> Any:
+        return self.call("configure_inbox_settings", kwargs)
+
+    def cleanup_expired(self, **kwargs: Any) -> Any:
+        return self.call("cleanup_expired", kwargs)
+
+    # --- account (also on extensions) -----------------------------------------
+
+    def get_account(self) -> Any:
+        return self.call("get_account", {})
+
+    def list_api_keys(self, **kwargs: Any) -> Any:
+        return self.call("list_api_keys", kwargs)
+
+    def create_api_key(self, **kwargs: Any) -> Any:
+        return self.call("create_api_key", kwargs)
+
+    def revoke_api_key(self, **kwargs: Any) -> Any:
+        return self.call("revoke_api_key", kwargs)
+
+    def list_payments(self, **kwargs: Any) -> Any:
+        return self.call("list_payments", kwargs)
+
+    def settle_balance(self, **kwargs: Any) -> Any:
+        return self.call("settle_balance", kwargs)
+
+    def submit_feature_request(self, **kwargs: Any) -> Any:
+        return self.call("submit_feature_request", kwargs)
+
+    def submit_exit_feedback(self, **kwargs: Any) -> Any:
+        return self.call("submit_exit_feedback", kwargs)
+
+    def delete_account(self, **kwargs: Any) -> Any:
+        return self.call("delete_account", kwargs)