Caper Wiki

Keyword search across the Caper knowledge base – the first call when you know what you are looking for but not where it lives. Matches page titles and body prose. A distinctive keyword is still the best query, but a whole question now works too: if the literal text is not found anywhere, it falls back to English full-text matching, which stems words and drops stopwords. NOT semantic – it reduces your question to its keywords, so it will not find a page that says "fee" when you asked about "cost". Ranked in four tiers: titles starting with the term, then titles containing it, then literal body hits, then full-text hits by relevance. Returns summaries only, each with a `path`, a `chars` size, and a 200-char snippet WINDOWED ON THE MATCH – the snippet shows you the passage that matched, so you can judge a result without opening it. Feed those `path` values to get_pages in one batched call – do NOT loop get_page over the results. If you want structure rather than a keyword, call get_categories (taxonomy) or list_pages (a whole branch). Defaults: page 1, pageSize 20 (max 50). Keep paging while `hasMore` is true.

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "Search term. One distinctive word or short phrase beats a sentence."
    },
    "page": {
      "type": "number",
      "description": "1-based page number (default 1)"
    },
    "pageSize": {
      "type": "number",
      "description": "Results per page (default 20, max 50)"
    }
  },
  "required": [
    "query"
  ]
}

Full text of ONE page in the Caper knowledge base. Address it by `path` ("dao-governance/concepts/voting/quadratic-voting" – exactly the `path` field the listing tools return), or by `tagPath` + `slug`. Use this only for a single known page: for 2 to 20 pages call get_pages instead, which is one round trip rather than N. Pass the path, not a page title. A miss returns near-match slugs so a wrong guess is recoverable in one retry.

{
  "type": "object",
  "properties": {
    "path": {
      "type": "string",
      "description": "Full page path, e.g. \"governance/voting\". Preferred over tagPath+slug."
    },
    "tagPath": {
      "type": "string",
      "description": "Tag path only, e.g. \"governance\" (\"\" for a top-level page). Ignored when `path` is set."
    },
    "slug": {
      "type": "string",
      "description": "Page slug, e.g. \"voting\". Ignored when `path` is set."
    }
  },
  "requireOneOf": [
    "path",
    "slug"
  ]
}

Batch read: full text of 1 to 20 pages in the Caper knowledge base in a single call. This is how you read search or listing results – calling get_page in a loop is the main way to waste round trips against this server. Pass `paths` exactly as the listing tools return them. Paths that do not exist come back in `missing` instead of failing the call, and anything past the 20-path cap comes back in `remaining` for a follow-up. Output is capped by `maxChars` (default 250000): pages past the cap are listed in `omitted` with their sizes, never silently dropped. Check the `chars` field in a listing first if your context budget is tight – a single operational page here can exceed 500 KB.

{
  "type": "object",
  "properties": {
    "paths": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Page paths, e.g. [\"economics/token-valuation\", \"desci/desci-funding\"]. 1-20 per call."
    },
    "maxChars": {
      "type": "number",
      "description": "Total character budget across returned pages (default 250000, max 1000000)"
    }
  },
  "required": [
    "paths"
  ]
}

Enumerate pages in the Caper knowledge base, newest first, optionally under one tag path. Use it to walk a branch you have already located (via get_categories, or the `tagPath` on a search hit); use search_wiki when you are hunting a keyword. `tagPath` matches the branch and everything beneath it – "daos" also returns "daos/dexs/...". Omit it to list the whole scope. Defaults: sort "updatedAt", page 1, pageSize 20 (max 100). Returns summaries only – pass the `path` values to get_pages for full text. `hasMore`/`nextPage` are the only truncation; nothing else is cut.

{
  "type": "object",
  "properties": {
    "tagPath": {
      "type": "string",
      "description": "Branch to list, e.g. \"daos\" or \"dao-governance/concepts\". Prefix match, includes descendants."
    },
    "sort": {
      "type": "string",
      "enum": [
        "title",
        "updatedAt"
      ],
      "description": "Sort order (default \"updatedAt\", newest first)"
    },
    "page": {
      "type": "number",
      "description": "1-based page number (default 1)"
    },
    "pageSize": {
      "type": "number",
      "description": "Results per page (default 20, max 100)"
    }
  }
}

Pages in the Caper knowledge base edited within the last N days, newest first – for "what changed?", not for finding a topic (search_wiki) or reading a branch (list_pages). Defaults: days 7 (max 30), limit 20 (max 50). `truncated: true` means the limit cut the list, not that the window is exhausted – raise `limit`, or page through list_pages sorted by updatedAt. Returns summaries only; feed the `path` values to get_pages.

{
  "type": "object",
  "properties": {
    "days": {
      "type": "number",
      "description": "Look back this many days (default 7, max 30)"
    },
    "limit": {
      "type": "number",
      "description": "Max pages returned (default 20, max 50)"
    }
  }
}

Curated taxonomy of the Caper knowledge base with page counts – call this FIRST when you are orienting rather than searching. Each node returns `path` (a tagPath you can hand straight to list_pages), `pageCount` (pages sitting directly at that path) and `pageCountDeep` (including every descendant), so you can tell an empty heading from a populated branch before spending a call. Takes no parameters.

{
  "type": "object",
  "properties": {}
}

The whole Caper knowledge base as one text document, for bulk ingestion. PREFLIGHT FIRST: call it with sizeOnly=true to get the exact character count, a token estimate, the per-branch breakdown and the largest pages – the corpus is big enough to swamp a context window and one operational page exceeds 500 KB on its own. Then pull it with `maxChars` (default 200000, max 1000000), or narrow it with `tagPath` to take one branch at a time. Truncation is page-aligned and honest: `truncated`, `omittedPages` and `nextSkip` say exactly where to resume (pass skip=nextSkip). If you only need a handful of pages, get_pages is cheaper.

{
  "type": "object",
  "properties": {
    "sizeOnly": {
      "type": "boolean",
      "description": "Return sizes and breakdowns only, no document. Do this before the first real pull."
    },
    "tagPath": {
      "type": "string",
      "description": "Restrict to one branch and its descendants, e.g. \"desci\". Omit for everything."
    },
    "maxChars": {
      "type": "number",
      "description": "Character budget for `document` (default 200000, max 1000000)"
    },
    "skip": {
      "type": "number",
      "description": "Resume from this page index – pass the `nextSkip` from the previous truncated call (default 0)"
    }
  }
}

Index of the DAOs on Caper: cashtag, name, description, member count, wiki URL, and that DAO's own MCP endpoint. Use it to resolve a name to a cashtag, then POST JSON-RPC to the returned `mcpEndpoint` to reach its get_ledger (treasury balances, proposal/trade/execution timeline, executed grants, inter-DAO funding) – this knowledge-base server deliberately has no ledger tool. `query` is a case-insensitive substring over cashtag, name and description. Defaults: limit 50 (max 200); `hasMore` says whether the cap cut the list.

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "Filter by cashtag, name or description (case-insensitive substring). Omit for all."
    },
    "limit": {
      "type": "number",
      "description": "Max DAOs returned (default 50, max 200)"
    }
  }
}

Step 1 of writing to Caper: a single-use ROLA challenge (5-minute expiry). The response includes the exact recipe for the message your Ed25519 key must sign. Writes are Stokenet-testnet only for now, and you always sign with your OWN key – nothing here custodies anything. Takes no parameters.

{
  "type": "object",
  "properties": {}
}

Step 2: exchange the signed ROLA proof for a 12h Bearer token – the same verification the human wallet flow runs. Send the returned token as an HTTP `Authorization: Bearer <token>` header on every later tool call; MCP arguments never carry it.

{
  "type": "object",
  "properties": {
    "challenge": {
      "type": "string",
      "description": "The challenge from get_challenge"
    },
    "address": {
      "type": "string",
      "description": "Your account address (virtual account of the signing key)"
    },
    "publicKey": {
      "type": "string",
      "description": "Ed25519 public key, hex"
    },
    "signature": {
      "type": "string",
      "description": "Signature over the ROLA message, hex"
    },
    "curve": {
      "type": "string",
      "enum": [
        "curve25519",
        "secp256k1"
      ],
      "description": "Signing curve (Ed25519 = \"curve25519\")"
    }
  },
  "required": [
    "challenge",
    "address",
    "publicKey",
    "signature",
    "curve"
  ]
}

Step 3: a ready-to-sign transaction manifest. Kinds: create-caper, buy, sell, create-proposal, vote, trigger. Per-kind parameters: create-caper needs name + cashtag + description (infoUrl/iconUrl/originToken optional); buy needs cashtag + xrd; sell needs cashtag + tokens; create-proposal needs cashtag + title + description + actionJson (one action object, or an ARRAY of up to 4 for a ranked ballot, as a JSON string — e.g. '{"kind":"PAYOUT","title":"Grant","currency":"<resource>","amount":100,"recipient":"<account>"}'). Governance is two-phase: 'vote' casts a ranked ballot (sequence = on-chain option indexes incl. the trailing Do-nothing, best first; proposerPaysFee answers who funds the execution fee) during the voting window; a supermajority pass arms 'trigger', which locks the trailing TWAP as the baseline and opens the market window: the winner executes unless the TWAP over that window is below the baseline. You sign and submit the manifest yourself with your own key, then register the txHash with submit_tx. Requires the Bearer token from the `login` tool, sent as an HTTP `Authorization: Bearer <token>` header on the POST carrying this call.

{
  "type": "object",
  "properties": {
    "kind": {
      "type": "string",
      "enum": [
        "create-caper",
        "buy",
        "sell",
        "create-proposal",
        "vote",
        "trigger"
      ],
      "description": "What the transaction does"
    },
    "account": {
      "type": "string",
      "description": "Your account address (pays fees, receives tokens)"
    },
    "cashtag": {
      "type": "string",
      "description": "Target caper's cashtag"
    },
    "name": {
      "type": "string",
      "description": "create-caper: the caper's name"
    },
    "description": {
      "type": "string",
      "description": "create-caper / create-proposal: description text"
    },
    "infoUrl": {
      "type": "string",
      "description": "create-caper: optional https project URL"
    },
    "iconUrl": {
      "type": "string",
      "description": "create-caper: optional icon URL (defaults to a generated one)"
    },
    "originToken": {
      "type": "string",
      "description": "create-caper: optional origin-token resource address (vampire launch)"
    },
    "xrd": {
      "type": "number",
      "description": "buy: $XRD to spend"
    },
    "tokens": {
      "type": "number",
      "description": "sell: caper tokens to sell"
    },
    "title": {
      "type": "string",
      "description": "create-proposal: proposal title"
    },
    "actionJson": {
      "type": "string",
      "description": "create-proposal: JSON for the action(s) — either ONE object, or an ARRAY of up to 4 that the voters rank against each other (a \"Do nothing\" option is always appended, so 4 actions make a 5-option ballot). Each is { kind: \"PAYOUT\" | \"INVEST\" | \"DIVEST\" | \"UPGRADE\" | \"METADATA\" | \"DEBATE\", … }. METADATA rewrites the token's mutable metadata (metadataDescription / metadataIconUrl / metadataInfoUrl — at least one). DEBATE is a non-executable position in a debate: title and description only, and winning it ends the proposal at the tally."
    }
  },
  "required": [
    "kind",
    "account"
  ]
}

Step 4: register a committed transaction by txHash. Kinds: create-caper, buy, sell, proposal, vote, trigger. The server verifies before mirroring anything: receipts are re-read on-ledger (forged or foreign txHashes are refused, replays are idempotent). Context per kind: create-caper takes cashtag; proposal takes proposalId. Requires the Bearer token from the `login` tool, sent as an HTTP `Authorization: Bearer <token>` header on the POST carrying this call.

{
  "type": "object",
  "properties": {
    "kind": {
      "type": "string",
      "enum": [
        "create-caper",
        "buy",
        "sell",
        "proposal",
        "vote",
        "trigger"
      ],
      "description": "What the transaction did"
    },
    "txHash": {
      "type": "string",
      "description": "The committed transaction intent hash (txid_…)"
    },
    "cashtag": {
      "type": "string",
      "description": "create-caper: the cashtag, so the response can confirm the row"
    },
    "proposalId": {
      "type": "number",
      "description": "proposal: the id from the create-proposal manifest response"
    }
  },
  "required": [
    "kind",
    "txHash"
  ]
}

Create or edit a page on a DAO's company-layer wiki. Holders only – any amount of the DAO's token, its vote token or its founder badge. Pass the body as one HTML string; it becomes a standard content block (headings, paragraphs, lists, tables). Requires the Bearer token from the `login` tool, sent as an HTTP `Authorization: Bearer <token>` header on the POST carrying this call.

{
  "type": "object",
  "properties": {
    "daoId": {
      "type": "string",
      "description": "Cashtag of the DAO whose wiki to edit"
    },
    "tagPath": {
      "type": "string",
      "description": "Optional tag path, e.g. \"updates\" (\"\" = top level)"
    },
    "slug": {
      "type": "string",
      "description": "Page slug"
    },
    "title": {
      "type": "string",
      "description": "Page title"
    },
    "html": {
      "type": "string",
      "description": "Page body as HTML, e.g. <h2>…</h2><p>…</p>"
    }
  },
  "required": [
    "daoId",
    "slug",
    "title",
    "html"
  ]
}