mcpscraper-memory-sdk 0.13.0__py3-none-any.whl

mcpscraper_memory/client.py

@@ -0,0 +1,115 @@
+import itertools
+import json
+from typing import Any
+
+import requests
+
+from .errors import MemoryApiError
+from ._generated_client import (
+    AccessNamespace,
+    CaptureNamespace,
+    ChannelsNamespace,
+    FactsNamespace,
+    GraphNamespace,
+    LibraryNamespace,
+    MemoryNamespace,
+    RecallNamespace,
+    ScheduleNamespace,
+    StorageNamespace,
+    TablesNamespace,
+    TagsNamespace,
+    VaultsNamespace,
+    VideoNamespace,
+    WebhooksNamespace,
+)
+
+DEFAULT_BASE_URL = "https://memory.mcpscraper.dev"
+
+
+class MemoryClient:
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = DEFAULT_BASE_URL,
+        session: requests.Session | None = None,
+    ) -> None:
+        self._api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        self._session = session or requests.Session()
+        self._rpc_id = itertools.count(1)
+
+        self.access = AccessNamespace(self._call_tool)
+        self.capture = CaptureNamespace(self._call_tool)
+        self.channels = ChannelsNamespace(self._call_tool)
+        self.facts = FactsNamespace(self._call_tool)
+        self.graph = GraphNamespace(self._call_tool)
+        self.library = LibraryNamespace(self._call_tool)
+        self.memory = MemoryNamespace(self._call_tool)
+        self.recall = RecallNamespace(self._call_tool)
+        self.schedule = ScheduleNamespace(self._call_tool)
+        self.storage = StorageNamespace(self._call_tool)
+        self.tables = TablesNamespace(self._call_tool)
+        self.tags = TagsNamespace(self._call_tool)
+        self.vaults = VaultsNamespace(self._call_tool)
+        self.video = VideoNamespace(self._call_tool)
+        self.webhooks = WebhooksNamespace(self._call_tool)
+
+    def _call_tool(self, name: str, arguments: dict[str, Any]) -> Any:
+        response = self._session.post(
+            f"{self._base_url}/mcp",
+            headers={
+                "content-type": "application/json",
+                "accept": "application/json, text/event-stream",
+                "authorization": f"Bearer {self._api_key}",
+            },
+            json={
+                "jsonrpc": "2.0",
+                "id": next(self._rpc_id),
+                "method": "tools/call",
+                "params": {"name": name, "arguments": arguments},
+            },
+        )
+
+        if not response.ok:
+            raise MemoryApiError(
+                f'HTTP {response.status_code} calling tool "{name}"',
+                http_status=response.status_code,
+                data=response.text,
+            )
+
+        payload = response.json()
+
+        if payload.get("error"):
+            error = payload["error"]
+            raise MemoryApiError(
+                error.get("message", f'tool "{name}" failed'),
+                rpc_code=error.get("code"),
+                data=error.get("data"),
+            )
+
+        result = payload.get("result") or {}
+        text_block = next(
+            (block.get("text") for block in result.get("content", []) if block.get("type") == "text"),
+            None,
+        )
+
+        parsed: Any = text_block
+        if isinstance(text_block, str):
+            try:
+                parsed = json.loads(text_block)
+            except ValueError:
+                parsed = text_block
+        if "structuredContent" in result:
+            parsed = result["structuredContent"]
+
+        if result.get("isError"):
+            message = (
+                parsed.get("message")
+                if isinstance(parsed, dict) and "message" in parsed
+                else parsed
+                if isinstance(parsed, str)
+                else f'Tool "{name}" failed'
+            )
+            raise MemoryApiError(str(message), tool_error=parsed)
+
+        return parsed

mcpscraper_memory/errors.py

@@ -0,0 +1,17 @@
+from typing import Any
+
+
+class MemoryApiError(Exception):
+    def __init__(
+        self,
+        message: str,
+        http_status: int | None = None,
+        rpc_code: int | None = None,
+        data: Any = None,
+        tool_error: Any = None,
+    ) -> None:
+        super().__init__(message)
+        self.http_status = http_status
+        self.rpc_code = rpc_code
+        self.data = data
+        self.tool_error = tool_error

mcpscraper_memory/mcp_client.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+import itertools
+import json
+import time
+from typing import Any
+
+import requests
+
+from ._mcp_generated_client import GeneratedMcpToolsClient
+
+
+class McpToolError(RuntimeError):
+    def __init__(
+        self,
+        message: str,
+        *,
+        http_status: int | None = None,
+        rpc_code: int | None = None,
+        data: Any = None,
+        tool_error: Any = None,
+    ) -> None:
+        super().__init__(message)
+        self.http_status = http_status
+        self.rpc_code = rpc_code
+        self.data = data
+        self.tool_error = tool_error
+
+
+class McpToolsClient(GeneratedMcpToolsClient):
+    """Typed access to every tool exposed by https://mcpscraper.dev/mcp."""
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "https://mcpscraper.dev",
+        session: requests.Session | None = None,
+        list_retries: int = 2,
+        retry_delay_s: float = 0.25,
+    ) -> None:
+        self._api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        self._session = session or requests.Session()
+        self._rpc_id = itertools.count(1)
+        self._list_retries = list_retries
+        self._retry_delay_s = retry_delay_s
+        super().__init__(self._call_tool)
+
+    def _request(self, method: str, params: dict[str, Any] | None = None) -> Any:
+        payload: dict[str, Any] = {
+            "jsonrpc": "2.0",
+            "id": next(self._rpc_id),
+            "method": method,
+        }
+        if params is not None:
+            payload["params"] = params
+        attempts = self._list_retries + 1 if method == "tools/list" else 1
+        response = None
+        for attempt in range(attempts):
+            response = self._session.post(
+                f"{self._base_url}/mcp",
+                headers={
+                    "x-api-key": self._api_key,
+                    "content-type": "application/json",
+                    "accept": "application/json, text/event-stream",
+                },
+                json=payload,
+            )
+            transient_discovery_failure = method == "tools/list" and response.status_code in (502, 503, 504)
+            if not transient_discovery_failure or attempt == attempts - 1:
+                break
+            time.sleep(self._retry_delay_s * (attempt + 1))
+        assert response is not None
+        if not response.ok:
+            raise McpToolError(
+                f'HTTP {response.status_code} calling MCP method "{method}"',
+                http_status=response.status_code,
+                data=response.text,
+            )
+        body = response.json()
+        if body.get("error"):
+            error = body["error"]
+            raise McpToolError(
+                error.get("message", f'MCP method "{method}" failed'),
+                rpc_code=error.get("code"),
+                data=error.get("data"),
+            )
+        if "result" not in body:
+            raise McpToolError(f'MCP method "{method}" returned no result')
+        return body["result"]
+
+    def list_tools(self) -> list[dict[str, Any]]:
+        result = self._request("tools/list")
+        return result.get("tools", [])
+
+    def describe_tool(self, name: str) -> dict[str, Any] | None:
+        return next((tool for tool in self.list_tools() if tool.get("name") == name), None)
+
+    def call_tool(self, name: str, args: dict[str, Any] | None = None) -> Any:
+        return self._call_tool(name, args or {})
+
+    @staticmethod
+    def _parsed_tool_value(result: dict[str, Any]) -> Any:
+        text_block = next(
+            (block.get("text") for block in result.get("content", []) if block.get("type") == "text"),
+            None,
+        )
+        parsed: Any = text_block
+        if isinstance(text_block, str):
+            try:
+                parsed = json.loads(text_block)
+            except ValueError:
+                parsed = text_block
+        if "structuredContent" in result:
+            parsed = result["structuredContent"]
+        return parsed
+
+    def call_tool_result(self, name: str, args: dict[str, Any] | None = None) -> dict[str, Any]:
+        """Return the complete MCP tool result, preserving image/audio/resource content blocks."""
+        result = self._request("tools/call", {"name": name, "arguments": args or {}})
+        parsed = self._parsed_tool_value(result)
+        if result.get("isError"):
+            message = (
+                parsed.get("message")
+                if isinstance(parsed, dict) and "message" in parsed
+                else parsed
+                if isinstance(parsed, str)
+                else f'Tool "{name}" failed'
+            )
+            raise McpToolError(str(message), tool_error=parsed)
+        return result
+
+    def _call_tool(self, name: str, arguments: dict[str, Any]) -> Any:
+        result = self.call_tool_result(name, arguments)
+        parsed = self._parsed_tool_value(result)
+        return parsed

mcpscraper_memory/mcp_models/access_accept_share.py

@@ -0,0 +1,17 @@
+from typing import Any, Literal
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class AccessAcceptShareInput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    share_id: str = Field(..., alias="shareId", description="The shareId from note-inbox to accept.")
+
+
+class AccessAcceptShareOutput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    ok: bool = Field(..., alias="ok", description="True on success; false on auth/scope/lookup error.")
+    share_id: str | None = Field(None, alias="shareId", description="The accepted share.")
+    owner: str | None = Field(None, alias="owner", description="Identity who shared the note.")
+    error: str | None = Field(None, alias="error", description="Human-readable failure reason when ok is false.")

mcpscraper_memory/mcp_models/access_approve_sender.py

@@ -0,0 +1,16 @@
+from typing import Any, Literal
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class AccessApproveSenderInput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    sender_identity: str = Field(..., alias="senderIdentity", description="Identity (email or user id) to approve as a sender.")
+
+
+class AccessApproveSenderOutput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    ok: bool = Field(..., alias="ok", description="True on success; false on auth error.")
+    sender: str | None = Field(None, alias="sender", description="The identity that was approved.")
+    error: str | None = Field(None, alias="error", description="Human-readable failure reason when ok is false.")

mcpscraper_memory/mcp_models/access_decline_share.py

@@ -0,0 +1,16 @@
+from typing import Any, Literal
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class AccessDeclineShareInput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    share_id: str = Field(..., alias="shareId", description="The shareId from note-inbox to decline.")
+
+
+class AccessDeclineShareOutput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    ok: bool = Field(..., alias="ok", description="True on success; false on auth/scope/lookup error.")
+    share_id: str | None = Field(None, alias="shareId", description="The declined share.")
+    error: str | None = Field(None, alias="error", description="Human-readable failure reason when ok is false.")

mcpscraper_memory/mcp_models/access_inbox_settings.py

@@ -0,0 +1,16 @@
+from typing import Any, Literal
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class AccessInboxSettingsInput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    allow_unapproved_senders: bool = Field(..., alias="allowUnapprovedSenders", description="Set true to accept invites/shares from anyone; false to require approval.")
+
+
+class AccessInboxSettingsOutput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    ok: bool = Field(..., alias="ok", description="True on success; false on auth error.")
+    allow_unapproved_senders: bool | None = Field(None, alias="allowUnapprovedSenders", description="The setting now in effect.")
+    error: str | None = Field(None, alias="error", description="Human-readable failure reason when ok is false.")

mcpscraper_memory/mcp_models/access_invite_account.py

@@ -0,0 +1,21 @@
+from typing import Any, Literal
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class AccessInviteAccountInput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    grantee_identity: str = Field(..., alias="granteeIdentity", description="Identity (email or user id) to invite into your full account.")
+    scope: dict[str, Any] | None = Field(None, alias="scope", description="Permissions to grant across your account. Optional; defaults to read+write (read, write, export, index, swap).")
+    revoke: bool | None = Field(None, alias="revoke", description="Set true to revoke an existing account invite for this grantee instead of granting one.")
+
+
+class AccessInviteAccountOutput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    ok: bool = Field(..., alias="ok", description="True on success; false on auth/scope error.")
+    grantee: str | None = Field(None, alias="grantee", description="The identity that was invited or revoked.")
+    granted: dict[str, Any] | None = Field(None, alias="granted", description="The permissions now in effect for the grantee. Absent on revoke.")
+    revoked: bool | None = Field(None, alias="revoked", description="True when an existing invite was removed.")
+    note: str | None = Field(None, alias="note", description="Guidance on next steps for the grantee.")
+    error: str | None = Field(None, alias="error", description="Human-readable failure reason when ok is false.")

mcpscraper_memory/mcp_models/access_issue_key.py

@@ -0,0 +1,26 @@
+from typing import Any, Literal
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class AccessIssueKeyInput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    grantee_identity: str = Field(..., alias="granteeIdentity", description="Identity that will own the newly issued key (e.g. an email or user id).")
+    vaults: list[str] = Field(..., alias="vaults", description="Vaults the new key is entitled to; the caller must already hold each. At least one required.")
+    scope: dict[str, Any] | None = Field(None, alias="scope", description="Scope grant (read/write/export/index/admin/swap). Optional; omit for least-privilege read-only.")
+    plan: Literal["free", "pro", "team", "enterprise"] | None = Field(None, alias="plan", description="Subscription plan carried by the key. Optional; defaults to free.")
+    expires_in_days: int | None = Field(None, alias="expiresInDays", description="Days until the key expires (1-3650). Optional; omit for a non-expiring key.")
+
+
+class AccessIssueKeyOutput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    ok: bool = Field(..., alias="ok", description="True when the key was issued; false on auth/scope error.")
+    key_id: str | None = Field(None, alias="keyId", description="Stable identifier of the issued key (safe to store/log).")
+    secret: str | None = Field(None, alias="secret", description="The key secret — RETURNED ONCE and never retrievable again. Capture it immediately.")
+    grantee: str | None = Field(None, alias="grantee", description="Identity the key was issued to.")
+    vaults: list[str] | None = Field(None, alias="vaults", description="Vaults the issued key is entitled to.")
+    scope: dict[str, Any] | None = Field(None, alias="scope", description="Normalized scope actually granted on the key.")
+    plan: str | None = Field(None, alias="plan", description="Subscription plan assigned to the key.")
+    expires_at: Any | None = Field(None, alias="expiresAt", description="ISO-8601 expiry timestamp, or null when the key does not expire.")
+    error: str | None = Field(None, alias="error", description="Human-readable failure reason when ok is false.")

mcpscraper_memory/mcp_models/access_list_approved_senders.py

@@ -0,0 +1,15 @@
+from typing import Any, Literal
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class AccessListApprovedSendersInput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class AccessListApprovedSendersOutput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    ok: bool = Field(..., alias="ok", description="True on success; false on auth error.")
+    approved_senders: list[str] | None = Field(None, alias="approvedSenders", description="Identities approved to reach you.")
+    allow_unapproved_senders: bool | None = Field(None, alias="allowUnapprovedSenders", description="True if your inbox is open to anyone regardless of this list.")
+    error: str | None = Field(None, alias="error", description="Human-readable failure reason when ok is false.")

mcpscraper_memory/mcp_models/access_list_keys.py

@@ -0,0 +1,17 @@
+from typing import Any, Literal
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class AccessListKeysInput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    vault: str | None = Field(None, alias="vault", description="Filter to keys entitled to this vault. Optional; omit to list across all vaults.")
+    plan: str | None = Field(None, alias="plan", description="Filter to keys on this plan (free/pro/team/enterprise). Optional; omit to list all plans.")
+
+
+class AccessListKeysOutput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    ok: bool = Field(..., alias="ok", description="True when the listing succeeded; false on auth/scope error.")
+    keys: list[dict[str, Any]] | None = Field(None, alias="keys", description="Key metadata for the caller identity. NEVER includes secrets. Present when ok is true.")
+    error: str | None = Field(None, alias="error", description="Human-readable failure reason when ok is false.")

mcpscraper_memory/mcp_models/access_note_inbox.py

@@ -0,0 +1,14 @@
+from typing import Any, Literal
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class AccessNoteInboxInput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class AccessNoteInboxOutput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    ok: bool = Field(..., alias="ok", description="True on success; false on auth error.")
+    pending: list[dict[str, Any]] | None = Field(None, alias="pending", description="Pending offers, oldest first. Present when ok is true.")
+    error: str | None = Field(None, alias="error", description="Human-readable failure reason when ok is false.")

mcpscraper_memory/mcp_models/access_remove_approved_sender.py

@@ -0,0 +1,17 @@
+from typing import Any, Literal
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class AccessRemoveApprovedSenderInput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    sender_identity: str = Field(..., alias="senderIdentity", description="Identity to remove from your approved-senders list.")
+
+
+class AccessRemoveApprovedSenderOutput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    ok: bool = Field(..., alias="ok", description="True on success; false on auth error.")
+    sender: str | None = Field(None, alias="sender", description="The identity that was removed.")
+    removed: bool | None = Field(None, alias="removed", description="True when an existing approval was found and removed.")
+    error: str | None = Field(None, alias="error", description="Human-readable failure reason when ok is false.")

mcpscraper_memory/mcp_models/access_revoke_key.py

@@ -0,0 +1,17 @@
+from typing import Any, Literal
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class AccessRevokeKeyInput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    key_id: str = Field(..., alias="keyId", description="Identifier of the key to revoke (from access-list-keys). Must be a key the caller owns or fully covers.")
+
+
+class AccessRevokeKeyOutput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    ok: bool = Field(..., alias="ok", description="True when the revoke operation completed; false on auth/scope error or not-found.")
+    key_id: str | None = Field(None, alias="keyId", description="The key that was targeted for revocation.")
+    revoked: bool | None = Field(None, alias="revoked", description="True if the key is now revoked.")
+    error: str | None = Field(None, alias="error", description="Human-readable failure reason when ok is false (e.g. \"key not found\").")

mcpscraper_memory/mcp_models/access_revoke_share.py

@@ -0,0 +1,16 @@
+from typing import Any, Literal
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class AccessRevokeShareInput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    share_id: str = Field(..., alias="shareId", description="The shareId to revoke.")
+
+
+class AccessRevokeShareOutput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    ok: bool = Field(..., alias="ok", description="True on success; false on auth/scope/lookup error.")
+    share_id: str | None = Field(None, alias="shareId", description="The revoked share.")
+    error: str | None = Field(None, alias="error", description="Human-readable failure reason when ok is false.")

mcpscraper_memory/mcp_models/access_set_scope.py

@@ -0,0 +1,19 @@
+from typing import Any, Literal
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class AccessSetScopeInput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    key_id: str = Field(..., alias="keyId", description="Identifier of the key to modify (from access-list-keys). Must be a key the caller owns.")
+    scope: dict[str, Any] | None = Field(None, alias="scope", description="New scope set. Partial; the provided keys are normalized and REPLACE the full existing scope. Optional, but supply scope and/or plan.")
+    plan: Literal["free", "pro", "team", "enterprise"] | None = Field(None, alias="plan", description="New subscription plan. Optional, but supply scope and/or plan.")
+
+
+class AccessSetScopeOutput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    ok: bool = Field(..., alias="ok", description="True when the change applied; false on auth/scope error, not-found, or nothing-to-change.")
+    key_id: str | None = Field(None, alias="keyId", description="The key that was targeted.")
+    updated: bool | None = Field(None, alias="updated", description="True if a row was actually updated.")
+    error: str | None = Field(None, alias="error", description="Human-readable failure reason when ok is false.")

mcpscraper_memory/mcp_models/access_share_note.py

@@ -0,0 +1,26 @@
+from typing import Any, Literal
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class AccessShareNoteInput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    vault: str | None = Field(None, alias="vault", description="Vault containing the note to share. Required (with path) unless shareId is given. Must be a vault you own.")
+    path: str | None = Field(None, alias="path", description="Vault-relative path of the note to share. Required (with vault) unless shareId is given.")
+    share_id: str | None = Field(None, alias="shareId", description="Instead of vault+path, re-share a note already shared to you by this shareId. Requires reshare permission on that share.")
+    grantee_identity: str = Field(..., alias="granteeIdentity", description="Identity to offer the note to.")
+    permissions: dict[str, Any] | None = Field(None, alias="permissions", description="Permissions to grant beyond read (always granted): edit (write back to the canonical note), delete (destroy the canonical note — dangerous), reshare (grantee may re-share onward). All default false.")
+    bundle_links: Any | None = Field(None, alias="bundleLinks", description="true to also share every detected linked note (same permissions as this share); an array of specific link refs (path or title, from a prior call's linkCandidates) to share only those. Omit or false to share none — default, and the safest choice when unsure.")
+
+
+class AccessShareNoteOutput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    ok: bool = Field(..., alias="ok", description="True when the offer was created; false on auth/scope/lookup error.")
+    share_id: str | None = Field(None, alias="shareId", description="Identifier the grantee will use to accept-share, then address the note on get/put/delete.")
+    grantee: str | None = Field(None, alias="grantee", description="The identity the note was offered to.")
+    permissions: dict[str, Any] | None = Field(None, alias="permissions", description="The permissions in effect for this share.")
+    note: str | None = Field(None, alias="note", description="Guidance: the offer is pending until the grantee calls accept-share.")
+    link_candidates: list[dict[str, Any]] | None = Field(None, alias="linkCandidates", description="Notes this one links to (same vault) that were NOT bundled into this share. Relay these to the human and ask before calling share-note again with bundleLinks if they want them included — otherwise they render as [[private note]] to this grantee.")
+    bundled: list[dict[str, Any]] | None = Field(None, alias="bundled", description="Linked notes that WERE bundled into this share as their own pending offers (per bundleLinks).")
+    error: str | None = Field(None, alias="error", description="Human-readable failure reason when ok is false.")

mcpscraper_memory/mcp_models/access_share_vault.py

@@ -0,0 +1,20 @@
+from typing import Any, Literal
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class AccessShareVaultInput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    vault: str = Field(..., alias="vault", description="Vault to share. The caller must control (be entitled to) this vault and hold write scope.")
+    grantee_identity: str = Field(..., alias="granteeIdentity", description="Identity to grant access to (e.g. an email or user id).")
+    scope: dict[str, Any] | None = Field(None, alias="scope", description="Entitlement scope to grant (read/write/export/index/admin/swap). Optional; omit for least-privilege read-only.")
+
+
+class AccessShareVaultOutput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    ok: bool = Field(..., alias="ok", description="True when the entitlement was written; false on auth/scope error.")
+    vault: str | None = Field(None, alias="vault", description="The vault that was shared.")
+    grantee: str | None = Field(None, alias="grantee", description="The identity that was granted access.")
+    note: str | None = Field(None, alias="note", description="Guidance on next steps (e.g. the grantee still needs a key tied to this vault).")
+    error: str | None = Field(None, alias="error", description="Human-readable failure reason when ok is false.")

mcpscraper_memory/mcp_models/access_swap_vault.py

@@ -0,0 +1,17 @@
+from typing import Any, Literal
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class AccessSwapVaultInput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    vault: str = Field(..., alias="vault", description="Vault to make active for the session. Must be an entitled vault and the key must hold \"swap\" scope.")
+
+
+class AccessSwapVaultOutput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    ok: bool = Field(..., alias="ok", description="True when the active vault was set; false on auth/scope error.")
+    active_vault: str | None = Field(None, alias="activeVault", description="The vault now active for the session.")
+    session: str | None = Field(None, alias="session", description="The session the active vault was set for.")
+    error: str | None = Field(None, alias="error", description="Human-readable failure reason when ok is false.")

mcpscraper_memory/mcp_models/access_switch_account.py

@@ -0,0 +1,18 @@
+from typing import Any, Literal
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class AccessSwitchAccountInput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    owner: str | None = Field(None, alias="owner", description="Identity whose account to make active. Must be your own identity (switch back) or one that has invited you. Omit to just list available accounts.")
+
+
+class AccessSwitchAccountOutput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    ok: bool = Field(..., alias="ok", description="True on success; false on auth/scope error.")
+    active_owner: str | None = Field(None, alias="activeOwner", description="The account now active for your identity (your own identity means your own account).")
+    is_own_account: bool | None = Field(None, alias="isOwnAccount", description="True when the active account is your own.")
+    available: list[str] | None = Field(None, alias="available", description="Identities whose accounts you can switch into (you have been invited).")
+    error: str | None = Field(None, alias="error", description="Human-readable failure reason when ok is false.")

mcpscraper_memory/mcp_models/access_unlink_share.py

@@ -0,0 +1,16 @@
+from typing import Any, Literal
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class AccessUnlinkShareInput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    share_id: str = Field(..., alias="shareId", description="The shareId to unlink from your \"Shared with me\" notes.")
+
+
+class AccessUnlinkShareOutput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    ok: bool = Field(..., alias="ok", description="True on success; false on auth/scope/lookup error.")
+    share_id: str | None = Field(None, alias="shareId", description="The unlinked share.")
+    error: str | None = Field(None, alias="error", description="Human-readable failure reason when ok is false.")

mcpscraper_memory/mcp_models/add_vault.py

@@ -0,0 +1,18 @@
+from typing import Any, Literal
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class AddVaultInput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    vault: str = Field(..., alias="vault", description="Name of the vault to create. Must match ^[A-Za-z0-9 _-]{1,48}$ (letters, digits, space, _ or -, 1-48 chars).")
+    owner: str | None = Field(None, alias="owner", description="Identity that should OWN the new vault (becomes the owner entitlement, so list-vaults reports role \"owner\" for them). Optional; defaults to the caller. Used when an admin bootstraps a personal vault on a user's behalf so the user owns it rather than receiving it as a share.")
+
+
+class AddVaultOutput(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+    ok: bool = Field(..., alias="ok", description="True when the request succeeded (whether or not a new vault was created); false on auth/scope/validation error.")
+    vault: str | None = Field(None, alias="vault", description="The vault name. Present when ok is true.")
+    created: bool | None = Field(None, alias="created", description="True if a new vault was created; false if it already existed (idempotent no-op). Present when ok is true.")
+    error: str | None = Field(None, alias="error", description="Human-readable failure reason when ok is false.")