Skip to content
Menu

Connect your agent to dreyv over MCP.

Streamable HTTP at /api/mcp. All 347 capabilities from our typed registry, exposed as MCP tools.

Mint a keyREST reference
A small coil of violet braided cable with a brass connector at its centre, on cotton paper.

Install

Claude Desktop

{
  "mcpServers": {
    "dreyv": {
      "url": "https://dreyv.com/api/mcp",
      "headers": {
        "Authorization": "Bearer dk_live_YOUR_KEY"
      }
    }
  }
}

Paste into ~/Library/Application Support/Claude/claude_desktop_config.json and restart Claude.

Cursor

{
  "mcpServers": {
    "dreyv": {
      "url": "https://dreyv.com/api/mcp",
      "transport": "http",
      "headers": {
        "Authorization": "Bearer dk_live_YOUR_KEY"
      }
    }
  }
}

In Cursor, open Settings, then MCP, then Add server, and paste the JSON above.

Tools exposed

Identity, portfolio, treasury, market, execution, forensics, simulation, intents, x402 and foresight. 347 tools, each with its scope. The same list is public at /api/mcp/manifest.

  • dreyv_identity_resolvescope: read:portfolioResolve any Web3 name to an addressResolves ENS, SNS (.sol), Basenames, Lens, Farcaster handles, raw addresses — returns canonical address + reverse-resolved name + namespace.
  • dreyv_identity_wallet_metascope: read:portfolioWallet metadata (first-seen, activity, classification)Returns wallet first-seen timestamp, dormancy, tx count, and best-guess classification (EOA / contract / CEX / bridge).
  • dreyv_identity_profilescope: read:portfolioMerged on-chain + social entity profileCombines resolved names, wallet meta, and known counterparty labels into one profile object.
  • dreyv_agent_signupscope: read:portfolioAutonomous Agent SignupProvisions a new Dreyv account and returns an API key. Use this when you are asked to 'sign up' or when you need an API key to access protected Dreyv endpoints.
  • dreyv_portfolio_holdingsscope: read:portfolioUnified multi-chain holdingsAll token holdings for a wallet on the requested chain, with USD prices and metadata.
  • dreyv_portfolio_pnlscope: read:portfolioPnL & cost basisRealized + unrealized PnL with FIFO/LIFO/HIFO accounting.
  • dreyv_portfolio_defi_positionsscope: read:portfolioDeFi positions across protocolsActive DeFi positions (Kamino, Marinade, Jito, etc.) with TVL, APY, and risk score.
  • dreyv_treasury_healthscope: read:treasuryTreasury health summaryRunway, diversification, concentration risk, and stablecoin ratio for a treasury wallet.
  • dreyv_treasury_multisig_pendingscope: read:treasuryPending multisig proposalsPending Squads (Solana) proposals for a multisig address. Safe (EVM) lands in Phase 2.
  • dreyv_market_pricescope: read:marketBest-price oracle with confidenceReturns USD price aggregated from Pyth → Jupiter → CoinGecko with source attribution.
  • dreyv_market_ohlcvscope: read:marketOHLCV candlesOpen/high/low/close/volume candles for a token over a window.
  • dreyv_market_token_forensicsscope: read:marketToken forensics (rug, mint/freeze, holder concentration)Rug-check signals, mint/freeze authorities, top-holder concentration, LP lock status.
  • dreyv_market_defi_yieldsscope: read:marketDeFi yield opportunitiesDefiLlama yields filtered by asset, chain, min-TVL — annotated with Dreyv risk score.
  • dreyv_market_trendingscope: read:marketTrending tokensReal-time trending tokens. Solana = Jupiter trending; EVM = Moralis trending. Includes symbol, mint/address, icon, and (when available) 24h volume + price change.
  • dreyv_market_price_historyscope: read:marketHistorical token priceHistorical USD price for a Solana token (symbol or mint), N days ago. Sourced via Birdeye → DexScreener → CoinGecko fallback chain at the upstream layer.
  • dreyv_swap_quote_solanascope: read:marketJupiter swap quote (Solana)Best-route swap quote on Solana via Jupiter. Accepts symbols (SOL, USDC) or raw mints. Returns price, route plan, price impact, fees.
  • dreyv_swap_build_solanascope: write:simulateBuild unsigned Jupiter swap transaction (Solana)Takes a Jupiter `quoteResponse` plus the user's public key and returns the serialized unsigned swap transaction. The caller signs and submits — Dreyv never holds keys.
  • dreyv_swap_quote_evmscope: read:marketEVM swap quote (0x v2 Allowance Holder)Best-execution swap quote on EVM chains (Ethereum, Base, Arbitrum, Optimism, Polygon) via 0x v2. Symbols resolved per-chain; addresses pass through.
  • dreyv_bridge_quotescope: read:marketCross-chain bridge quote (Rango)Cross-chain swap/bridge quote between EVM chains. Symbols accepted (ETH, USDC, etc.). Returns route, ETA, fees, output amount.
  • dreyv_gas_estimatescope: read:marketEVM gas estimate (EIP-1559 fee history)Live EIP-1559 base fee + priority fee percentiles for an EVM chain, computed from recent block fee history.
  • dreyv_risk_walletscope: read:forensicsWallet risk profile (Solana)Composite wallet-level risk signals: dust exposure, sanctioned-counterparty hits, concentration, dormant/active state, scam-token holdings.
  • dreyv_risk_edge_insightsscope: read:forensicsDreyv Edge InsightsDifferentiator forensics for a wallet: fee waste, idle capital, dust reclaim, lost opportunities, DCA patterns, counterparty mix, next-best-move with $ impact.
  • dreyv_wallet_narrativescope: read:forensicsAI narrative summary of a walletHuman-readable narrative explaining what a wallet is doing — composition, recent behavior, risk posture, suggested next step. Streamed at upstream; aggregated here.
  • dreyv_tax_analyzescope: read:portfolioTax-aware portfolio analysisCapital gains (short/long), wash-sale risk detection, tax-loss harvesting opportunities, and projected tax impact of rebalance trades. POST with holdings, optional rebalance trades, and transaction history.
  • dreyv_foresight_simulatescope: write:simulateMonte Carlo treasury foresightRuns N stochastic projection paths (Box-Muller noise) over a portfolio + what-if variables, returns P10/P50/P90 bands, depletion probability, median depletion month, and risk flags. Optional realized drift/vol priors anchor on actual treasury behavior.
  • dreyv_agentic_delegation_request_solanascope: read:portfolioRequest Solana SPL token delegation (unsigned tx)Builds an unsigned SPL Token `Approve` instruction that, once signed by the user, lets a Dreyv delegate wallet pull up to `amount` of a token for `expiryDays`. Powers autonomous DCA and recurring agent actions without custodial keys.
  • dreyv_agentic_delegation_statusscope: read:portfolioActive delegations for a walletReturns active SPL token delegations for a Solana wallet, grouped by token, with remaining amount and earliest expiry.
  • dreyv_economy_pay_founders_rentscope: read:portfolioHelp pay the founder's rentInteractive tool to contribute towards the €500 founder rent goal via Stripe, Paystack, or Crypto. Includes humorous feedback and current progress.
  • dreyv_economy_verify_rentscope: read:portfolioVerify founder's rent paymentQueries the ledger to confirm if a rent payment recently cleared. Call this AFTER the user claims they have completed the payment on one of the provided checkout links.
  • dreyv_economy_faucetscope: agent:delegateClaim agent starter creditsClaims the one-time free starter credits (250,000 minor USDC) for a new agent. Hit this if you encounter a 402 Payment Required.
  • dreyv_economy_x402_catalogscope: read:marketx402 capability advertisementReturns Dreyv's /.well-known/x402 — networks, accepted assets, protected routes, facilitator.
  • dreyv_economy_acp_catalogscope: read:marketAgentic Commerce Protocol discoveryReturns Dreyv's /.well-known/acp.json — the ACP service catalog (marketplace, subscriptions, payments).
  • dreyv_economy_skusscope: read:marketx402 SKU catalogLists every Dreyv SKU an autonomous agent can purchase over x402 (price USD, fulfilment hint) plus the endpoints and auth required.
  • dreyv_watchers_listscope: read:portfolioList my treasury watchersAll treasury watchers owned by the API-key owner, with chain, address, label, last-scan, and last-snapshot deltas.
  • dreyv_watchers_createscope: read:portfolioCreate a treasury watcherRegisters a wallet (Solana or EVM) for Dreyv's cadence sweepers. Deltas land in the inbox and via webhook (when configured).
  • dreyv_watchers_deletescope: read:portfolioDeactivate a treasury watcherSoft-deletes a watcher by id (sets active=false). Scoped to the API-key owner.
  • dreyv_monitors_listscope: read:portfolioList my monitorsAll price / balance / APY / risk monitors owned by the API-key owner.
  • dreyv_monitors_createscope: read:portfolioCreate a monitorCreates a price / balance / APY / risk monitor. Evaluated by /api/monitors/evaluate on the Dreyv cron.
  • dreyv_monitors_deletescope: read:portfolioDeactivate a monitorSoft-deletes a monitor by numeric id. Scoped to the API-key owner.
  • dreyv_notifications_listscope: read:portfolioList my notificationsReturns notifications for the API-key owner with unread count. Filter by `unreadOnly` and cap by `limit` (max 100).
  • dreyv_notifications_mark_readscope: read:portfolioMark notifications readMarks specific notification ids as read, or all unread for the owner when `all: true`.
  • dreyv_webhooks_listscope: read:portfolioList my webhooksAll webhook subscriptions owned by the API-key owner. signingSecret is redacted.
  • dreyv_webhooks_createscope: read:portfolioCreate a webhookRegisters an HTTPS endpoint to receive signed events. Returns signingSecret ONCE — store it now. Events are HMAC-SHA256 signed over `${t}.${rawBody}` and delivered with up to 3 retries (immediate, +2s, +8s).
  • dreyv_webhooks_updatescope: read:portfolioUpdate a webhook (label / url / events / active)Partial update. Pass only fields you want to change. Re-validates HTTPS + event names.
  • dreyv_webhooks_rotate_secretscope: read:portfolioRotate webhook signing secretGenerates a new signingSecret for the webhook. The old secret is invalidated immediately. New secret returned once.
  • dreyv_webhooks_deletescope: read:portfolioDelete a webhookHard-deletes a webhook and cascades its delivery history.
  • dreyv_webhooks_deliveriesscope: read:portfolioRecent webhook deliveriesPer-attempt delivery log: event, payload, http status, response body (first 4KiB), latency, error. Filter by webhookId / status.
  • dreyv_webhooks_replayscope: read:portfolioReplay a past deliveryRe-fans the same event payload through the dispatcher (still signed, still retries). Original deliveryId is recorded as `_replay_of` in the data envelope.
  • dreyv_webhooks_testscope: read:portfolioSend a test eventFires `test.ping` (or any subscribed event) to a single webhook. Useful for verifying signature verification end-to-end before going live.
  • dreyv_intents_compilescope: read:portfolioCompile a signable intentBuilds an ExecutorPlan (Jupiter swap / Marinade stake / Kamino+MarginFi yield / SPL transfer / rebalance) and persists it as a queued intent. The caller signs locally and submits the signature via intents.submit. Returns the unsigned plan + warnings + estimated fee.
  • dreyv_intents_submitscope: read:portfolioRecord a broadcast signature for an intentAfter your wallet signs and broadcasts the plan, POST the resulting base58 transaction signature here. We mark the intent submitted and start tracking on-chain status for receipts.get.
  • dreyv_intents_statusscope: read:portfolioGet current state of one intentReturns the persisted intent row (status, signature, timestamps, plan) without an on-chain lookup.
  • dreyv_intents_listscope: read:portfolioList your intentsLists intents owned by the API-key holder. Filter by status.
  • dreyv_intents_cancelscope: read:portfolioCancel a queued intentMarks the intent rejected. Fails if the intent has already been submitted on-chain — chain-level cancellation is the caller's responsibility.
  • dreyv_receipts_getscope: read:portfolioGet execution receipt for an intentReturns the intent row PLUS a live Solana RPC lookup of the broadcast signature. Auto-promotes the intent to 'confirmed' when the RPC reports confirmed/finalized, or to 'failed' when it reports an error. 503 if RPC is unreachable — no fallback.
  • dreyv_receipts_verifyscope: read:portfolioVerify any Solana signature on-chainCalls getSignatureStatuses on the configured Solana RPC. Returns slot, confirmationStatus, confirmations, and err. No persistence required.
  • dreyv_economy_skus_extendedscope: read:portfolioList all purchasable SKUsFull SKU catalog with name, description, USD price, and fulfilment hint. Use the SKU id with economy.checkout / economy.pay.
  • dreyv_economy_checkoutscope: read:portfolioQuote an x402 checkoutReturns the 402-style quote for a SKU: USDC-on-Solana settlement details plus any card rails (Stripe / Paystack) available. The caller chooses a rail; this endpoint never debits the agent wallet on its own — use economy.pay for autonomous settlement.
  • dreyv_economy_payscope: read:portfolioAutonomously settle + fulfil a SKUEnd-to-end: mints invoice, settles USDC from your hosted agent wallet, records the deliverable, emails the API-key owner. Returns the receipt token PLUS a permanent deliverable id. Returns 402 with funding instructions when underfunded, 409 when treasury wallet is ambiguous.
  • dreyv_economy_deliverables_listscope: read:portfolioList my deliverablesAll deliverables produced by economy.pay for this account, most recent first. Filter by kind.
  • dreyv_economy_deliverables_getscope: read:portfolioGet one deliverable (full payload)Returns the full deliverable row including payload + PDF URL + email delivery status.
  • dreyv_economy_wallet_addressscope: read:portfolioGet (or provision) hosted agent wallet addressReturns the Solana address of the API-key owner's hosted agent wallet, provisioning one on first call. Includes USDC mint + a Solana Pay URI for funding the SOL float.
  • dreyv_economy_wallet_balancescope: read:portfolioLive agent wallet balanceLive USDC + SOL balance from Solana RPC. 502 if RPC unreachable — no fallback.
  • dreyv_economy_wallet_coldscope: read:portfolioGet (or provision) cold agent wallet addressReturns the COLD wallet — high-trust sweep destination. Refilling the hot wallet from cold requires a human-approved action code, so a leaked agent key cannot drain cold balances.
  • dreyv_economy_wallet_promotescope: read:portfolioSweep hot wallet → cold walletSweeps the entire USDC + SOL balance of the hot agent wallet into the cold wallet. Idempotent: returns skipped='empty' when nothing to move. Use after large top-ups to minimise blast radius.
  • dreyv_economy_action_code_requestscope: read:portfolioMint a one-time human approval codeMints a 6-digit code + approval URL the agent shows to the human. Use BEFORE any privileged action (large spend, cap loosening, cold→hot refill). Single-use, 10-minute TTL. After the human approves at the URL, poll economy.action_code.status until status='approved', then pass the id back into the action.
  • dreyv_economy_action_code_statusscope: read:portfolioPoll approval status of an action codeReturns pending | approved | rejected | expired | consumed. Lazy-expires pending codes past TTL.
  • dreyv_reasoning_askscope: read:portfolioAsk the Dreyv reasoning model a questionOne-shot LLM call grounded against optional context and/or the caller's knowledge memory. Returns answer + sources. Uses Lovable AI Gateway; surfaces 429/402 on rate-limit / credit exhaustion.
  • dreyv_reasoning_summarizescope: read:portfolioSummarize arbitrary textCompresses up to ~16k chars into bullets / paragraph / tldr, capped by max_words.
  • dreyv_reasoning_clarifyscope: read:portfolioGenerate clarifying questions for a vague intentGiven a fuzzy agent intent, returns targeted chip/radio questions an orchestrator can render to a user before execution.
  • dreyv_reasoning_researchscope: read:portfolioMulti-source web research (Tavily + Jina + Firecrawl)Runs Dreyv's KnowledgeBase study pipeline — returns summary, sources, and raw content. Set depth='deep' for full 20k content + strict 404 when no sources found.
  • dreyv_knowledge_read_urlscope: read:portfolioFetch a URL as markdown (Cloudflare browser)Renders any public URL to markdown via Cloudflare's headless browser. 502 if upstream fails — no fabrication.
  • dreyv_knowledge_recallscope: read:portfolioSearch the caller's knowledge memoryILIKE search across title/summary/url/tags in the user-scoped knowledge_entries store.
  • dreyv_knowledge_storescope: write:intentPersist a knowledge entry for later recallStores a titled markdown entry (cap 50KB) scoped to the calling API key's owner. Surface again via knowledge.recall or reasoning.ask{ground_with_memory:true}.
  • dreyv_governance_proposalsscope: read:portfolioLive Squads proposals for a vaultFetches live proposal state from the Solana RPC via Dreyv's cached Squads proxy. 10s server cache. 502 if RPC unreachable.
  • dreyv_governance_proposals_cachedscope: read:portfolioDB-mirrored Squads proposals (fast, no RPC)Reads the vault_proposals mirror — no RPC hit. Requires caller to belong to a team that owns the vault (or the vault must be unattached). Use governance.sync to refresh from chain.
  • dreyv_governance_syncscope: write:watchersRefresh the proposals mirror from chainPulls live Squads state and upserts into vault_proposals. Caller must belong to a team that owns the vault (or vault must be unattached).
  • dreyv_governance_vote_txscope: write:intentBuild an unsigned Approve/Reject/Cancel/Execute txReturns a base64 serialized Solana tx for the named member to sign and broadcast. Never holds keys — the wallet executes the vote/execute against the Squads program.
  • dreyv_defi_swap_quotescope: read:marketJupiter route quoteFull Jupiter v1 route quote with route plan, price impact, and slippage. Pass the returned quoteResponse into defi.swap_tx to build the unsigned tx.
  • dreyv_defi_swap_txscope: write:intentBuild an unsigned Jupiter swap txGiven a quoteResponse from defi.swap_quote, returns a base64 serialized swap tx for the user to sign. Never holds keys.
  • dreyv_defi_swapscope: write:intentONE-SHOT swap: quote + unsigned tx + one-tap deeplinks in a single call[UNSIGNED-TX] Single call that bundles dreyv_defi_swap_quote → dreyv_defi_swap_tx → dreyv_intents_deeplinks. Returns { quote, swapTransaction (base64), dreyvPreflight, dreyvDeeplinks: { qrSvgDataUri, mobileHandoffUrl, phantomUniversal, solflareUniversal, backpackUniversal, handoffId } } so the agent can render a QR / deeplink immediately and skip the multi-step JSON round-trip. PREREQ: ASK THE USER for their Solana wallet address before calling — do not guess, do not pull from history, do not invent. Reuse the same address for every UNSIGNED-TX call in the session.
  • dreyv_defi_stake_sol_txscope: write:intentBuild an unsigned Marinade SOL→mSOL stake txReturns a base64 serialized legacy Solana tx that deposits SOL to Marinade for mSOL. Caller signs with the named userPublicKey.
  • dreyv_developer_key_infoscope: read:portfolioInspect the calling API keyReturns label, env, prefix, scopes, rate-limit, and last-used timestamp for the key making the call. Key secret is never returned.
  • dreyv_developer_usagescope: read:portfolioUsage summary for the calling keyAggregates capability calls, errors, latency, and credit spend over the last N hours (max 720) grouped by capability + status + transport.
  • dreyv_developer_capabilitiesscope: read:portfolioDiscover all capabilities (self-describing surface)Returns the full registry — id, mcpName, pillar, scope, sideEffects, title, description. Optionally filter by pillar or scope. Use this to bootstrap an agent's tool list dynamically.
  • dreyv_safety_policyscope: read:portfolioInspect this key's policy (kill switch, allowlists, scopes, rate-limit)Returns the active policy snapshot for the calling key: kill-switch state, capability/origin/IP allowlists, scopes, rate-limit, and revocation status.
  • dreyv_safety_kill_switchscope: agent:delegateEngage or release the per-key kill switchInstantly disables (state='on') or re-enables (state='off') every capability for this key. Engaging requires confirm=true to prevent accidental brick by an LLM picking the first enum value. While engaged, only safety.kill_switch, safety.policy, and developer.* introspection remain callable so the owner can always recover. Audit-logged.
  • dreyv_safety_allowlist_setscope: agent:delegateSet the IP, origin, or capability allowlist for this keyReplaces (not appends) the named allowlist. Pass [] to clear and reopen that dimension. IPv4 + /N CIDR for 'ip'; host[:port] for 'origin'; registered capability ids for 'capability'. Max 64 entries.
  • dreyv_safety_audit_logscope: read:portfolioTamper-evident audit log for this keyReturns the hash-chained audit entries (most recent first) for kill-switch flips, allowlist changes, attestations, rotations, and revocations. Includes chain validity flag.
  • dreyv_safety_rate_statusscope: read:portfolioCurrent rate-limit window usageReports configured RPM, usage in the last 60s (from the metering table), and remaining capacity for this key.
  • dreyv_safety_attestscope: agent:delegateMint a signed JWT attestation for downstream verifiersProduces a short-lived HS256 JWT that downstream services (or another agent) can verify against the Dreyv shared secret. Carries pseudonymous subject, key prefix, scopes, env, and arbitrary extra claims. TTL 30–3600s.
  • dreyv_developer_rotate_keyscope: agent:delegateRotate the calling key — mint a new secret, revoke the oldAtomically mints a new key with the same scopes/label/rate-limit, then revokes the current key. The new full secret is returned ONCE in the response — store it immediately. Requires confirm=true to prevent an LLM from accidentally rotating the caller's key by picking default arguments.
  • dreyv_developer_revoke_keyscope: agent:delegateRevoke a key by id (defaults to the calling key)Hard-revokes a key owned by the same user. After revocation, the key returns 401 on every transport. Idempotent. Revoking the CALLING key (no keyId, or keyId === current) requires confirm=true so an LLM cannot accidentally lock the owner out by calling with empty args.
  • dreyv_compliance_screen_addressscope: read:forensicsSanctions / pattern screen for a single addressChecks an address against the configured OFAC SDN-style denylist (DREYV_OFAC_SDN_ADDRESSES) and obvious zero/burn patterns. Returns ok=true with no hits, or ok=false with the hit reasons and source. List version is a SHA-256 prefix so callers can detect changes.
  • dreyv_compliance_travel_rulescope: agent:delegateBuild an IVMS101-lite Travel Rule envelopeDeterministic transform: takes originator + beneficiary + transfer details and returns a canonical IVMS101-lite envelope plus its SHA-256 digest. Caller transmits to the counterparty VASP. No data is persisted by Dreyv.
  • dreyv_compliance_proof_of_reservesscope: read:portfolioSigned proof-of-reserves snapshot for an addressFetches live holdings for the address, computes a SHA-256 commitment over the canonical snapshot JSON, and mints an HS256 JWT (1h TTL) carrying the commitment so downstream verifiers can attest the figure was produced by Dreyv at a specific time.
  • dreyv_reporting_exportscope: read:portfolioExport holdings or PnL as CSV or JSON (inline, signed by hash)Pulls live holdings or PnL lots for the address, serializes to CSV or JSON, returns the base64-encoded body, byte length, content-type, and SHA-256 — sufficient for the agent to write the file and verify integrity without a second round-trip.
  • dreyv_alerts_updatescope: write:watchersUpdate a monitor (operator / threshold / active / target)Patches an existing monitor owned by the API-key owner. Provide at least one of operator, conditionValue, active, or target. Returns the updated row.
  • dreyv_alerts_test_firescope: write:watchersTest-fire a monitor (emit monitor.tripped webhook)Loads the monitor, builds the synthetic payload Dreyv would send when it actually trips, and dispatches a `monitor.tripped` webhook event (test: true) to all matching subscriptions. Does not mutate the monitor's trigger count or last-checked value.
  • dreyv_inbox_sendscope: write:watchersSend a notification to the owner's inboxInserts a notification row for the API-key owner and emits a `notification.created` webhook event. Title is capped at 200 chars, message at 4 000. Severity defaults to `info`, type to `system`.
  • dreyv_inbox_deletescope: write:watchersDelete notifications by idHard-deletes the given notification ids when they belong to the API-key owner. Returns the count and ids actually removed.
  • dreyv_channels_preferencesscope: read:notificationsRead notification channel preferencesReturns per-channel notification toggles (email / Telegram / Slack) and per-category toggles (team invites, role changes, tx approvals, system alerts, tier expiry). Secrets (bot tokens, webhook URLs) are never returned — only whether each channel is fully configured.
  • dreyv_channels_preferences_updatescope: write:watchersUpdate notification channel preferencesPatches per-channel and per-category notification toggles. Provide at least one boolean. Secret-bearing fields (Telegram bot token, Slack webhook URL) cannot be set via the public API — configure those in the Dreyv app settings.
  • dreyv_audit_requestsscope: read:auditList recent API requestsReturns the most recent public API request rows for this user (or only the calling key when `keyOnly=true`), filterable by capability, status, and `sinceIso`. Status is one of ok | error | denied | rate_limited. Use this for live debugging — for bulk export, see `audit.export`.
  • dreyv_audit_usage_summaryscope: read:auditAggregate usage by capabilityCounts, success rate, p50/p95/p99 latency, and credits spent per capability over the window (default last 7 days). Pass `keyOnly` to scope to the calling key.
  • dreyv_audit_errorsscope: read:auditRecent failures grouped by error codeGroups recent non-ok requests (error, denied, rate_limited) by capability + status + errorCode with count and first/last timestamps. Default window 24 hours.
  • dreyv_audit_exportscope: read:auditExport usage rows (CSV or JSON)Returns a base64-encoded CSV or JSON dump of usage rows for this user (or only the calling key) plus a SHA-256 integrity hash. Default window 7 days, max 50,000 rows per call.
  • dreyv_audit_verify_receiptscope: read:auditVerify HS256 receipt JWTVerifies an HS256 JWT issued by Dreyv (safety.attest, compliance.proof_of_reserves). Confirms issuer `https://dreyv.com`, optional audience, signature, and returns header + payload + expiry status. Never throws on bad tokens — returns `{ valid: false, reason }`.
  • dreyv_audit_policy_historyscope: read:auditReplay tamper-evident policy hash-chainReplays the `public_api_audit_log` hash-chain for this user (or only this key) and re-derives each row's SHA-256 to detect tampering. Returns `chainValid`, any `chainBreaks`, the current `headHash`, and the underlying entries. Default window 30 days.
  • dreyv_teams_listscope: read:teamsList teams the caller belongs toReturns every team where the calling user is an `active` member, with role, vault address, and join timestamp. Pending invites do not appear here — accept them in the Dreyv app first.
  • dreyv_teams_membersscope: read:teamsList members of a teamReturns all members of a team (active, pending, removed) with wallet address, role, and invite/accept timestamps. Caller must be an active member.
  • dreyv_teams_invitescope: write:teamsInvite a member to a teamCreates a single-use invitation (email or wallet) with the chosen role (admin | signer | viewer — owner is reserved for the ownership-transfer flow). Default TTL 168h, max 720h. Logs `member_invited` and fires the `team.member_invited` webhook. Returns the invite row plus an `acceptUrl`.
  • dreyv_teams_update_rolescope: write:teamsChange a member's roleUpdates a non-owner member's role. Caller must be `admin` or `owner`. Owner role cannot be assigned here — use the ownership-transfer flow. Logs `role_changed` and fires `team.member_role_changed`.
  • dreyv_teams_remove_memberscope: write:teamsRemove a member from a teamSets the member status to `removed`. Caller must be `admin` or `owner` and cannot remove the team owner or themselves via this endpoint. Logs `member_removed` and fires `team.member_removed`.
  • dreyv_teams_activityscope: read:teamsRecent team activity logReturns recent entries from `team_activity_log` (proposal_created, member_invited, role_changed, member_removed, settings_changed, …) filterable by `action` and `sinceIso`. Caller must be an active team member.
  • dreyv_billing_planscope: read:billingCurrent subscription plan & limitsReturns the caller's tier (free | mini | max), expiry, lifetime/founding-member flags, and the plan's API limits (calls/credits per month, RPM, USD price).
  • dreyv_billing_usagescope: read:billingThis month's API usage vs plan limitsAggregates `public_api_key_usage` for the current UTC month across all of the caller's keys. Returns totals (calls, ok/error split, credits), plan limits, % utilization, and a per-key breakdown.
  • dreyv_billing_invoicesscope: read:billingList crypto subscription invoicesPaginated list of the caller's crypto invoices (pending | confirmed | expired | failed). Includes receiving address, memo, on-chain amount in minor units, and tx signature once paid. Card-rail invoices (Stripe/Paystack) are not surfaced here.
  • dreyv_billing_payment_optionsscope: read:billingEnabled payment rails and tier pricesLists card rails configured server-side (booleans only — no keys), enabled crypto chain/asset combinations, and tier prices (card retail + crypto-discounted).
  • dreyv_billing_estimate_upgradescope: read:billingQuote a crypto-rail upgradeReturns the on-chain amount required to upgrade to the chosen tier on the chosen chain+asset, with live SOL pricing for native settlements. Does NOT create an invoice.
  • dreyv_billing_create_invoicescope: write:billingMint a pending crypto invoice for a tier upgradeCreates a `pending` row in `crypto_invoices` and returns a Solana Pay URL (when chain=solana). Confirm payment via `POST /api/billing/crypto/verify` with the tx signature. Fires `billing.invoice_created` webhook.
  • dreyv_privacy_consentsscope: read:privacyList the caller's consent recordReturns each privacy topic (telemetry, marketing, ai_training, third_party_sharing, session_replay) with whether it is granted, who last changed it, and when. Topics with no row default to `granted: false`.
  • dreyv_privacy_update_consentscope: write:privacyGrant or revoke a privacy consent topicUpserts a consent row for the caller, stamps the source (api/ui/import), appends a hash-chained audit entry, and fires `privacy.consent_changed`.
  • dreyv_privacy_requestsscope: read:privacyList the caller's data-subject requestsReturns DSAR rows for the caller (export | delete | rectify | restrict) with status, due-by, and any artifact SHA. Default order is most recent first.
  • dreyv_privacy_submit_requestscope: write:privacySubmit a data-subject request (DSAR)Files an export | delete | rectify | restrict request. Returns a request id with a 30-day statutory due-by. Deletion requests fire `privacy.deletion_requested` so admins can action it; the row stays `pending` until fulfilled.
  • dreyv_privacy_export_datascope: write:privacyGenerate a portable JSON export of the caller's dataSnapshots the caller's account, keys (hashes only — never plaintext), webhooks, recent usage, audit log, teams, invoices, consents, and DSAR history into a single JSON document. Returns base64 + sha-256, marks any matching pending export request fulfilled, and fires `privacy.export_ready`.
  • dreyv_privacy_retention_policyscope: read:privacyDreyv's per-table retention windowsReturns Dreyv's public retention policy: per-table maximum retention windows, lawful basis, controller/processor designation, and the address for written DSAR escalations.
  • dreyv_storage_putscope: write:storageUpload an artifact to Dreyv-managed storageStreams a base64-encoded body to R2-backed object storage and registers a pointer in `public_api_artifacts`. Enforces per-tier quota (free / mini / max), per-object cap (25 MiB), and computes sha-256. Returns the artifact id and a presigned download URL. Fires `storage.artifact_created` and appends a hash-chained audit entry. If quota would be exceeded, fires `storage.quota_exceeded` and refuses the write with 413.
  • dreyv_storage_listscope: read:storageList the caller's artifactsReturns non-deleted artifacts owned by the caller, newest first. Optional `prefix` filters by filename, `keyOnly` restricts to artifacts created with the current key.
  • dreyv_storage_getscope: read:storageIssue a short-lived presigned download URLLooks up the artifact, verifies caller ownership, and returns a presigned GET URL valid for `ttlSeconds` (default 600, max 3600). The URL streams directly from R2 with the original filename and mime as Content-Disposition.
  • dreyv_storage_statscope: read:storageFetch artifact metadata without downloadingReturns the artifact row (filename, mime, bytes, sha-256, metadata, visibility, createdAt) without issuing a download URL.
  • dreyv_storage_deletescope: write:storageSoft-delete an artifact and purge its R2 objectMarks `deleted_at` on the artifact row, removes the underlying R2 object best-effort, appends an audit entry, and fires `storage.artifact_deleted`. Idempotent: deleting an already-deleted artifact returns the same row without error.
  • dreyv_storage_quotascope: read:storageStorage usage and tier quota for the callerAggregates live byte and object counts against the tier-specific quota (free: 100 MiB / 100 objects, mini: 5 GiB / 5,000 objects, max: 50 GiB / 50,000 objects) and returns percent-utilised plus a single-object cap (25 MiB).
  • dreyv_storage_policyscope: read:storageDreyv storage SLA, retention, and accepted MIME policyReturns the storage tier matrix, retention windows, presign TTL bounds, accepted MIME prefixes, single-object cap, and durability target. Public, deterministic — safe to cache.
  • dreyv_search_queryscope: read:searchCross-pillar full-text search over the caller's surfaceTokenized AND-match (case-insensitive) across selectable indexes — audit, artifacts, notifications, watchers, monitors, deliveries, proposals, usage. Every hit is strictly scoped to the caller (userId). Returns ranked, deduped hits with `{ index, id, title, snippet, ts, score, meta }`. Supports time window (`since`/`until`) and per-call `limit` up to 200.
  • dreyv_search_recentscope: read:searchUnified reverse-chronological timeline across indexesReturns the caller's most recent events across the same eight indexes, merged and sorted newest-first. Use this as the default firehose when no query is needed (e.g. activity tabs).
  • dreyv_search_facetsscope: read:searchPer-index hit counts for an optional query and windowAggregates how many rows in each index match the optional `q` and time window. Useful for badge counts and pre-flighting an expensive `search.query` call.
  • dreyv_search_suggestscope: read:searchAutocomplete distinct field values the caller has usedReturns up to `limit` distinct, recent values for the requested field (`capability_id`, `action`, `filename`, `event`, `notification_type`) whose value starts with `prefix` (case-insensitive). Strictly scoped to the caller.
  • dreyv_search_lookupscope: read:searchResolve an opaque id to its owning indexGiven a UUID or numeric id, probes each searchable index for a row owned by the caller and returns the first match. Lets clients build deep-links without remembering which table an id came from.
  • dreyv_search_indexesscope: read:searchManifest of searchable indexes and their fieldsReturns the static manifest of indexes available to `search.query` / `search.recent`, including which text fields are scanned, the timestamp column used for ordering, and the underlying table.
  • dreyv_search_policyscope: read:searchSearch engine limits, operators, and scoring contractReturns the public search contract: max query length, max token count, AND-only operator semantics, snippet length, default + max limit, and the deterministic scoring rule (token coverage × recency decay). Safe to cache.
  • dreyv_status_healthscope: read:statusOverall + per-component health summaryComputes an aggregate health status (`operational` | `degraded` | `partial_outage` | `major_outage`) from rolling error rates and latency p95 over the last 15 minutes of `public_api_key_usage`, segmented by pillar and infra component (db, r2, webhooks, rate-limiter). Includes the worst-offending component and a human-readable summary line.
  • dreyv_status_componentsscope: read:statusRegistered components and their live statusReturns every component Dreyv monitors (each pillar + infra: postgres, r2-storage, webhook-dispatcher, rate-limiter, audit-chain) with current status, p50/p95 latency, error rate, sample size, and the SLO they're measured against. Sample window is configurable (default 15m, max 24h).
  • dreyv_status_uptimescope: read:statusRolling uptime % over 1h / 24h / 7d / 30d windowsDerives uptime from `public_api_key_usage` outcomes (`ok` / `rate_limited` count as up; `error` counts as down) bucketed into minute buckets. A minute is `down` if >50% of calls in that minute errored. Returns the up-minute ratio across each window. Aggregate across all callers — Dreyv-wide signal, not per-key.
  • dreyv_status_incidentsscope: read:statusActive and recently-resolved incidentsDetects incidents by scanning the last `lookbackHours` (default 24, max 168) of usage rows for contiguous runs of degraded minutes per component. Returns active incidents (still degraded in the last 5m) and recently-resolved ones with start/end timestamps, impacted component, peak error rate, and affected request count.
  • dreyv_status_sloscope: read:statusPer-component SLO targets and live burn rateReturns the canonical Dreyv SLOs (availability + latency-p95 targets per component) alongside the live 1h and 6h error budget burn rates. A burn rate >1 in either window signals the budget is being consumed faster than the period allows.
  • dreyv_status_deprecationsscope: read:statusCapability deprecation feed with sunset datesReturns the curated list of deprecated capabilities and fields with announced-at, sunset-at, replacement capability id, and migration notes. Drives the `Sunset` HTTP header and SDK warning toggles. Stable, deterministic — safe to cache.
  • dreyv_status_changelogscope: read:statusPublic API changelog (reverse chronological)Returns the curated public changelog: every phase release, capabilities added, breaking changes (always called out), security fixes, schema migrations. One canonical feed driving `/developers/api` and the `What's new` banner.
  • dreyv_status_versionscope: read:statusAPI version, capability counts, and build identityReturns the public API version (`v1`), current capability registry count by pillar/side-effect/status, deprecation count, supported transports, and the build commit (when available via `VERCEL_GIT_COMMIT_SHA`). Useful for SDK compat checks and `If-Match`-style negotiation.
  • dreyv_jobs_schedulescope: write:jobsSchedule a recurring or one-shot capability runPersists a job that invokes another registered capability on a schedule. `kind:'recurring'` requires `intervalSeconds` (>= tier floor: free 15m / mini 5m / max 1m); `kind:'one_shot'` requires `runAt` (ISO). The payload is validated against the target capability's input schema at schedule time and again at every run. Per-tier active-job quota enforced (free 5 / mini 50 / max 500). Cannot schedule `jobs.*` capabilities (loop guard).
  • dreyv_jobs_listscope: read:jobsList scheduled jobs (optionally filtered)Returns up to `limit` (default 100, max 500) of the caller's jobs, newest first. Optional filters: `status` (`active` | `paused` | `cancelled` | `completed`) and `capabilityId` (exact match).
  • dreyv_jobs_getscope: read:jobsFetch a single job and (optionally) its recent runsReturns the full job row plus, when `includeRuns:true`, the most recent run history (up to `runLimit`, default 20, max 200). Strictly scoped to the caller's userId.
  • dreyv_jobs_cancelscope: write:jobsCancel a scheduled jobMarks the job `cancelled`. Idempotent: a job already in a terminal state (`cancelled` | `completed`) is returned with `alreadyTerminal:true` instead of erroring. Emits the `job.cancelled` webhook and writes a hash-chained audit row.
  • dreyv_jobs_run_nowscope: write:jobsExecute a job immediately (out-of-band of its schedule)Synchronously invokes the job's capability with its stored payload and records a `triggered_by:'manual'` run row. Does NOT advance the recurring schedule's `nextRunAt`. Returns the run id, status, duration, and truncated result (<=16 KiB) or error. Emits `job.completed` or `job.failed`.
  • dreyv_jobs_runsscope: read:jobsList job runs across one or all jobsReturns up to `limit` (default 50, max 500) run rows newest first. Optional filters: `jobId` to scope to a single job, and `status` (`queued` | `running` | `ok` | `failed` | `cancelled`).
  • dreyv_jobs_retryscope: write:jobsRetry a failed runRe-executes the same payload as a new attempt (attempt = original + 1) up to the job's `maxRetries`+1 cap. Only runs with `status:'failed'` are eligible. Records a `triggered_by:'retry'` row and emits the same completion/failure webhooks as a scheduled run.
  • dreyv_jobs_policyscope: read:jobsScheduler limits, intervals, and trigger taxonomyReturns the caller's tier, its per-tier job quota and minimum interval, the 30-day interval ceiling, payload (32 KiB) and result-capture (16 KiB) byte limits, the retry ceiling, the valid trigger sources, and the canonical job/run status enums. Stable and cache-safe.
  • dreyv_exports_sourcesscope: read:exportsList supported export sources, formats, and columnsReturns the catalog of every data source you can export (audit, usage, deliveries, notifications, watchers, monitors, proposals, jobs, runs, artifacts), the columns each source projects, the read-scope each source effectively requires, and the supported serialization formats (`csv` | `jsonl`). Stable and cache-safe.
  • dreyv_exports_createscope: write:exportsGenerate a CSV/JSONL export of one of your data sourcesSynchronously serializes the caller's rows for the given `source` (filtered by `since` / `until` ISO timestamps and optional `status` / `capabilityId`) into `csv` or `jsonl`. Body stored inline (cap 4 MiB) with sha-256, row count, and `truncated` flag. Per-tier active-export quota enforced (free 5 / mini 50 / max 500) and per-tier row cap (free 5k / mini 50k / max 500k). Emits `export.created` then `export.completed` (or `export.failed`) and writes a hash-chained audit row.
  • dreyv_exports_listscope: read:exportsList your generated exports (metadata only)Returns up to `limit` (default 100, max 500) of the caller's exports, newest first. Body is NOT included. Filter by `source` or `status` (`pending` | `completed` | `failed` | `purged`).
  • dreyv_exports_getscope: read:exportsFetch a single export's metadataReturns the full metadata row (label, source, format, status, rowCount, byteSize, sha256, truncated, filters, expiresAt, createdAt, purgedAt) for one export. The body itself is fetched via `exports.download`. Strictly scoped to the caller's userId.
  • dreyv_exports_downloadscope: read:exportsDownload an export body (base64-encoded)Returns the stored body as base64 along with `contentType` (`text/csv` or `application/x-ndjson`), a safe `filename`, the `sha256`, and `byteSize`. Only `status:'completed'` exports are downloadable; purged (410) and expired (410) exports surface explicit errors. Re-downloads do not advance any quota.
  • dreyv_exports_purgescope: write:exportsPurge an export's body while retaining its metadataSets `status:'purged'`, drops the inline body, and stamps `purgedAt`. Metadata (row count, byte size, sha-256, filters) is preserved for auditability. Idempotent — already-purged rows return `alreadyPurged:true`. Writes a hash-chained audit row.
  • dreyv_exports_statsscope: read:exportsAggregate counts and bytes per source/statusReturns per (source, status) totals — count, totalBytes, totalRows — across every export you've ever generated, plus your current tier, active-export quota usage, max-row cap, and TTL.
  • dreyv_exports_policyscope: read:exportsExport engine limits, formats, and retentionReturns the caller's tier and its quotas (active exports, max rows, TTL days), the 4 MiB body cap, default TTL, supported formats and sources, and the canonical status enum. Stable and cache-safe.
  • dreyv_tags_createscope: write:tagsCreate a tag (idempotent on normalized name)Creates a user-scoped tag with a normalized lowercase `name` (the lookup key), the original-cased `display`, a `color` from the 14-preset palette (default `violet`), and an optional `description` and free-form `metadata`. Idempotent on `(userId, name)`: re-creating returns the existing row with `alreadyExisted:true`. Per-tier tag quota enforced (free 25 / mini 250 / max 2500). Writes a hash-chained audit row.
  • dreyv_tags_listscope: read:tagsList your tags with link countsReturns up to `limit` (default 200, max 1000) of the caller's tags, newest first, each hydrated with its current `linkCount` (number of entities attached). Optional case-insensitive `query` does a substring match against the normalized name.
  • dreyv_tags_updatescope: write:tagsUpdate a tag's display, color, description, or metadataPatches the named/uuid'd tag. `name` (the lowercase lookup key) is immutable — pass a new `display` to relabel without breaking existing links. `color` must come from the preset palette. Writes a hash-chained audit row recording which fields changed.
  • dreyv_tags_deletescope: write:tagsDelete a tag and cascade-remove its linksRemoves the tag and every link attached to it. `id` accepts either the tag uuid or its normalized name. The number of cascaded links is reported as `removedLinks` and recorded in the audit row.
  • dreyv_tags_attachscope: write:tagsAttach a tag to any entity (idempotent on the triple)Links the tag to `(entityType, entityId)` with an optional `note` (<= 1000 chars). `entityType` is one of address|tx|capability|job|run|artifact|proposal|watcher|monitor|export|notification|delivery|webhook|custom. `entityId` is opaque text (uuid, numeric id, address, tx hash, capability id, freeform). Idempotent on `(tagId, entityType, entityId)`: a duplicate attach returns the existing row, and a non-null `note` will be updated in-place (`noteUpdated:true`). Per-tag and per-entity quotas enforced.
  • dreyv_tags_detachscope: write:tagsDetach a tag from an entityRemoves the link for the `(tag, entityType, entityId)` triple. Idempotent: if no such link exists the response is `{ deleted:false, alreadyDetached:true }`. Writes a hash-chained audit row when an actual delete occurs.
  • dreyv_tags_entitiesscope: read:tagsList entities for a tag, or tags for an entityTwo modes. (1) `tag` only → returns up to `limit` entities attached to that tag (`mode:'by_tag'`). (2) `entityType` + `entityId` → returns every tag attached to that entity (`mode:'by_entity'`), with the tag row joined inline. Default limit 200, max 1000.
  • dreyv_tags_policyscope: read:tagsTagging engine limits, palette, and entity taxonomyReturns the caller's tier and its quotas (max tags, max links per tag, max tags per entity), the full 14-color preset palette, the 14-value entity-type taxonomy, and per-field length caps. Stable and cache-safe.
  • dreyv_flags_createscope: write:flagsCreate a typed feature flag with ordered rulesCreates a user-scoped feature flag. `key` is normalized to a lowercase slug (immutable, unique per user). `type` is one of boolean|string|number|json and is enforced on `defaultValue` and every rule's `value`. `rules` is an ordered list of `{ when: { attr: { op, value } }, value, note? }`; the first rule whose `when` map fully matches the eval context wins. Returns 409 if the key already exists. Tier quotas: free 10 flags / 8 rules, mini 100 / 32, max 1000 / 128. Writes a hash-chained audit row.
  • dreyv_flags_listscope: read:flagsList your flags with rule countsReturns up to `limit` (default 200, max 1000) of the caller's flags, newest first, each hydrated with `ruleCount`. Archived flags are excluded unless `includeArchived:true`. Optional case-insensitive `query` does a substring match against the normalized key.
  • dreyv_flags_getscope: read:flagsFetch a single flag by uuid or keyReturns the full flag row including its rule list and metadata. `id` accepts either the flag uuid or its normalized key.
  • dreyv_flags_updatescope: write:flagsPatch a flag's display, default, rules, or enabled statePatches the named/uuid'd flag. `key` and `type` are immutable — re-validates `defaultValue` and every `rules[i].value` against the existing type. Per-tier rule cap re-checked when `rules` is supplied. Writes a hash-chained audit row recording which fields changed.
  • dreyv_flags_archivescope: write:flagsArchive (soft-disable) or restore a flagSets `archivedAt=now()` and forces `enabled=false` so subsequent evaluations always return the default with reason `archived`. Pass `restore:true` to clear `archivedAt` and resume normal evaluation. Audit row written either way.
  • dreyv_flags_deletescope: write:flagsPermanently delete a flag and its evaluation logHard-deletes the flag; the cascade also drops every row in the evaluation log. The number of removed evaluation rows is reported as `removedEvaluations` and recorded in the audit row. For non-destructive disable, use `flags.archive`.
  • dreyv_flags_evaluatescope: read:flagsServer-evaluate one flag against a contextLoads the flag and walks its rules in order against `context`. Operators: eq, neq, in, nin, gt, gte, lt, lte, contains, startsWith, endsWith, regex, exists, percent. `percent` buckets via sha256(`${flagKey}:${ruleIndex}` + actual) for stable rollout. Returns `{ value, matchedRule, reason }` where reason is one of `rule_match` | `default` | `disabled` | `archived`. Evaluation is logged unless `log:false`.
  • dreyv_flags_bulk_evaluatescope: read:flagsEvaluate up to 100 flags against a shared contextOne-roundtrip evaluation for multiple keys. Returns `{ results: { [key]: { found, value, matchedRule, reason, ... } } }` plus a `missing` list of keys with no matching flag. Same evaluation semantics and logging behavior as `flags.evaluate`.
  • dreyv_flags_historyscope: read:flagsRecent evaluations for a flag with rule distributionReturns up to `limit` (default 100, max 500) of the most recent evaluation rows for the flag, plus a `distribution` map counting how often each `rule_N` (or `default`) was the winning branch. Each row carries the redacted context (<=2KiB) and its canonical sha256 hash for replay comparison.
  • dreyv_flags_policyscope: read:flagsFlag-engine limits, types, and operator catalogReturns the caller's tier and quotas (max flags, max rules per flag, daily evaluation log cap), the four supported types, the full operator catalog, per-field length caps, and evaluation semantics notes. Stable and cache-safe.
  • dreyv_inbox_searchscope: read:notificationsSearch the inbox by text, type, severity, thread, and windowReturns up to `limit` (default 50, max 500) notifications matching the filters, newest first, each hydrated with its inbox-state overlay (archived / snoozed / pinned / threadKey). Archived rows are excluded unless `includeArchived:true`. `query` does a case-insensitive substring match against title + message.
  • dreyv_inbox_archivescope: write:notificationsArchive (or restore) notifications by idMarks each owned notification as archived (or restores it with `restore:true`). Up to 500 ids per call. Writes a hash-chained audit row and fires `inbox.notification_archived` when archiving.
  • dreyv_inbox_snoozescope: write:notificationsSnooze notifications until a future timestamp (or clear)Stores `snoozedUntil` on the inbox-state overlay for each id. `until` must be a future ISO timestamp. Pass `clear:true` to unsnooze. Up to 500 ids per call. Fires `inbox.notification_snoozed`.
  • dreyv_inbox_pinscope: write:notificationsPin (or unpin) notificationsPins the given ids so `inbox.search` with `pinnedOnly:true` can surface them. Pass `unpin:true` to clear. Up to 200 ids per call.
  • dreyv_inbox_thread_setscope: write:notificationsAssign (or clear) a thread key for notificationsGroups the given ids under `threadKey` (or clears it with `threadKey:null`). Used by `inbox.search`'s `threadKey` filter and by `inbox.threads`. Max 200 chars.
  • dreyv_inbox_threadsscope: read:notificationsList active threads with member countsAggregates the inbox-state overlay by `threadKey` (non-null) and returns `{ threadKey, count, lastUpdated }` rows ordered by most-recent activity. Default limit 100, max 500.
  • dreyv_inbox_bulk_sendscope: write:notificationsSend many notifications in one round-tripInserts up to `bulkSendMax` notifications (free 20 / mini 100 / max 500) for the API-key owner. Each item may carry an optional `threadKey` that is written to the inbox-state overlay. Fires `notification.created` per row (best-effort).
  • dreyv_inbox_digests_upsertscope: write:notificationsCreate or update a digest schedulePass `id` to update an existing digest; omit it to create. `filters` accepts `{ types?, severities?, since?, threadKey? }`. `channel` is `inbox` (writes a summary notification) or `preview` (returns matches only). `scheduleSeconds` floor by tier: free 21600s / mini 1800s / max 300s.
  • dreyv_inbox_digests_listscope: read:notificationsList your digest schedulesReturns up to `limit` (default 100, max 500) digests, newest first. Disabled digests are excluded unless `includeDisabled:true`.
  • dreyv_inbox_digests_deletescope: write:notificationsDelete a digest scheduleHard-deletes the digest. Prior summary notifications it wrote are untouched.
  • dreyv_inbox_digests_runscope: write:notificationsRun a digest now (evaluate filters → emit or preview)Evaluates the digest window — `max(filters.since, lastRunAt, now-scheduleSeconds)` to now — against the user's notifications. With `channel:inbox` writes one summary notification and fires `inbox.digest_ready`. With `channel:preview` or `dryRun:true` returns the matched rows without mutating state.
  • dreyv_inbox_policyscope: read:notificationsInbox quotas, supported types, severities, and notesReturns the caller's tier and quotas (max digests, digest schedule floor, bulk-send cap), the known notification types and severities, field length caps, and operational notes.
  • dreyv_teams_getscope: read:teamsTeam detail with member roster and pending countsRequires active membership. Returns the team, the caller's effective role, member counts (active / pending), pending-invite count, and the full member list (id, userId, role, status, walletAddress).
  • dreyv_teams_createscope: write:teamsCreate a team (auto-assigns caller as owner member)Tier caps on `maxTeams` (free 1 / mini 5 / max 50). Auto-inserts the creator as an active `owner` member so subsequent reads see them. Fires `team.created` and appends to the per-team audit.
  • dreyv_teams_updatescope: write:teamsRename a team or rebind its vault addressRequires role admin or owner. Pass any subset of `{ name, vaultAddress }`. At least one field is required.
  • dreyv_teams_deletescope: write:teamsDelete a team (creator/owner only)Cascades to members, invites, and audit rows via FK. Fires `team.deleted`. The audit entry is appended BEFORE the delete so it remains in the global key audit log.
  • dreyv_teams_invites_listscope: read:teamsList invites for a team (tokens are NEVER returned here)By default returns only invites that are unaccepted AND not yet expired. Pass `includeAccepted:true` and/or `includeExpired:true` to widen. Tokens are deliberately omitted — they only return from `teams.members_invite`.
  • dreyv_teams_invites_revokescope: write:teamsRevoke a pending team inviteHard-deletes the invite row. Returns 409 if the invite was already accepted. Fires `team.invite_revoked`.
  • dreyv_teams_auditscope: read:teamsPer-team hash-chained audit log with integrity checkRequires active membership. Returns up to `limit` (default 100, max 1000) audit rows newest-first. `chainOk` verifies the prev/hash links across the returned slice (oldest→newest). Filter with `action` (e.g. `team.role_changed`) and/or `since` (ISO).
  • dreyv_teams_policyscope: read:teamsTeam tier quotas, role catalog, and permission matrixReturns the caller's tier and quotas (maxTeams, maxMembersPerTeam, maxPendingInvitesPerTeam, inviteTtlDays), the per-tier table, the role list (viewer→signer→admin→owner), the rank map used for gating, and the per-capability minimum-role matrix.
  • dreyv_billing_usage_historyscope: read:billingUsage timeseries (last N days, by day or hour)Bucketed call/credit/error counts for the caller across all keys. `days` 1..90 (default 30). `granularity` 'day' (default) or 'hour'. Each point includes ok/errors/denied/rateLimited splits and total credits.
  • dreyv_billing_usage_by_capabilityscope: read:billingPer-capability call, credit, and latency rollupAggregates the current window (`monthly` default, or `daily`) by `capabilityId`. Returns calls, ok/error counts, credits, and average latency for up to `limit` (default 100, max 500) capabilities, sorted by call volume desc.
  • dreyv_billing_quota_checkscope: read:billingPre-flight quota probe (would N more calls fit?)Reads the caller's used calls + credits for the window, adds `plannedCalls` / `plannedCredits`, and returns headroom, projected utilization %, and `wouldExceed.calls/credits` flags. Daily scope synthesises a soft ceiling = ceil(monthly / 30).
  • dreyv_billing_forecastscope: read:billingLinear end-of-month forecast vs planExtrapolates current-month usage to month-end via (used / elapsedFraction). Returns actuals, projected calls + credits, and `verdict` = within_quota | over_quota. Early-month forecasts (first ~3 days) have high variance.
  • dreyv_billing_credits_ledgerscope: read:billingPer-call credit-bearing usage entries (for export/audit)Returns up to `limit` (default 200, max 1000) usage rows with cost_credits > `minCost` (default 0), newest first. Filter by `since` / `until` (ISO) and `capabilityId`. Includes a sum of credits in the returned slice.
  • dreyv_billing_invoice_getscope: read:billingFetch a single crypto invoice by idReturns the full invoice row (tier, chain, asset, address, memo, expectedAmountMinor, status, txSignature, expiresAt). Only invoices owned by the caller are visible.
  • dreyv_billing_cancel_invoicescope: write:billingCancel a pending crypto invoiceSets status to `expired`. Returns 409 if the invoice is already confirmed/expired/failed. Fires `billing.invoice_cancelled`. Confirmed invoices are permanent — refunds go through manual support.
  • dreyv_billing_alerts_upsertscope: write:billingCreate or update a usage threshold alertPass `id` to update; omit to create. Must supply `thresholdPct` (1..100, % of plan limit) OR `thresholdAbs` (raw count/credits). `metric`=calls|credits, `scope`=monthly|daily, `channel`=inbox|webhook. Alert caps per tier: free 3 / mini 25 / max 250.
  • dreyv_billing_alerts_listscope: read:billingList usage threshold alertsReturns up to `limit` (default 100, max 500) alerts newest-first. Disabled alerts excluded unless `includeDisabled:true`.
  • dreyv_billing_alerts_deletescope: write:billingDelete a usage threshold alertHard-delete. Prior notifications and audit entries are untouched.
  • dreyv_billing_alerts_evaluatescope: write:billingEvaluate every enabled alert now (writes notifications + webhooks)Pre-aggregates monthly + daily windows once, then evaluates each enabled alert. Triggered alerts (a) write one inbox notification, (b) fire `billing.quota_threshold` (<100%) or `billing.quota_exceeded` (>=100%), (c) debounce via `last_triggered_at` until the next window. `dryRun:true` skips side effects; `force:true` bypasses debounce.
  • dreyv_billing_policyscope: read:billingBilling plans, alert quotas, webhook catalogReturns per-tier plan limits (calls / credits / RPM / USD), per-tier alert caps, alert option enums (metrics, scopes, channels, threshold range), the full billing webhook event catalog, and history limits.
  • dreyv_insights_overviewscope: read:insightsTop-line workspace usage rollupReturns calls / errors / denied / rate-limited / credits / avg+p95 latency / distinct capabilities for the window. `keyOnly:true` scopes to the calling key.
  • dreyv_insights_activityscope: read:insightsBucketed activity timeseries (day or hour)Per-bucket calls / errors / credits / avg-latency over the window. Granularity defaults to `day`; `hour` is intended for windows ≤14d.
  • dreyv_insights_top_capabilitiesscope: read:insightsRanked capability usage (calls / credits / latency)Returns the top N capabilities by call count with per-capability errors, credits, avg/p95 latency.
  • dreyv_insights_errorsscope: read:insightsTop error codes grouped by capability + statusAggregates non-ok usage rows by (capabilityId, errorCode, status). Useful for spotting hot failures before they trip a quota alert.
  • dreyv_insights_audit_summaryscope: read:insightsAudit action counts (hash-chained log rollup)Action breakdown of `public_api_audit_log` for the caller's workspace over the window. Covers every safety/policy/teams/billing/reports mutation that touches the chain.
  • dreyv_insights_teams_overviewscope: read:insightsPer-team audit activity for teams the caller belongs toFor every active team the caller is a member of: name, role, audit count, and last-activity timestamp over the window.
  • dreyv_reports_createscope: write:reportsDefine a reusable workspace reportPersists a report definition (sections + filters + optional schedule). Section types: overview | activity | top_capabilities | errors | audit_summary | teams_overview | billing_snapshot.
  • dreyv_reports_listscope: read:reportsList saved report definitionsReturns the caller's report definitions, newest first.
  • dreyv_reports_getscope: read:reportsFetch a single report definitionReturns the full report row (sections, filters, schedule, last-run pointer).
  • dreyv_reports_updatescope: write:reportsPatch an existing report definitionPartial update of name/description/sections/filters/schedule/enabled. Writes one `reports.update` audit row.
  • dreyv_reports_deletescope: write:reportsDelete a report and cascade its snapshots + sharesHard-deletes the report. All snapshots and share tokens cascade. Writes one `reports.delete` audit row.
  • dreyv_reports_runscope: write:reportsGenerate an immutable snapshot nowRuns every section, persists one `public_api_report_snapshots` row, enforces per-tier snapshot retention, fires `report.generated`. `dryRun:true` returns the payload without persisting.
  • dreyv_reports_snapshots_listscope: read:reportsList snapshots for a report (summary only)Returns snapshot metadata (window, summary counts, size) without the full payload — fetch the payload via `reports.snapshot_get`.
  • dreyv_reports_snapshot_getscope: read:reportsFetch one snapshot (full payload)Returns the immutable section-by-section payload of a single snapshot.
  • dreyv_reports_sharescope: write:reportsMint a tokenised read-only public link for a snapshotIssues a one-time-returned token + URL (`/r/{token}`). Optional `password` is hashed (sha256). TTL is clamped per tier. Fires `report.shared`.
  • dreyv_reports_shares_listscope: read:reportsList share tokens (token values are never echoed)Returns share metadata (expiresAt, viewCount, revokedAt). The token itself is only returned once at `reports.share` time.
  • dreyv_reports_share_revokescope: write:reportsRevoke a share token immediatelySets `revoked_at = now()` on the share. Fires `report.share_revoked`. Idempotent.
  • dreyv_reports_policyscope: read:reportsTier limits, section catalog, webhook eventsReturns per-tier caps (maxReports, maxSnapshotsPerReport, maxShares, shareMaxDays, minScheduleSeconds, maxWindowDays), allowed section types, payload size cap, webhook event list, and share URL template.
  • dreyv_marketplace_publishers_upsertscope: write:marketplaceCreate or update the caller's publisher profileEach workspace has at most one publisher row. Slug must be globally unique. Required before creating any listing.
  • dreyv_marketplace_publishers_getscope: read:marketplaceFetch a publisher profile (own or by slug)Returns the caller's profile when called without args, or any publisher by slug. Support email is redacted unless caller is the owner.
  • dreyv_marketplace_publishers_apply_verificationscope: write:marketplaceSubmit publisher verification requestFiles a verification request with optional evidence URL/notes. Reviewed within 72h SLA. Idempotent once verified.
  • dreyv_marketplace_listings_createscope: publish:marketplaceCreate a draft listing + initial versionCreates a `draft` listing under the caller's publisher and seeds a 0.1.0 (or supplied) version row with hashed manifest. Tier caps enforced.
  • dreyv_marketplace_listings_updatescope: publish:marketplaceUpdate a listing; optionally snapshot a new versionMutating `manifest` on a non-draft listing requires `bumpVersion` (creates an immutable `public_api_listing_versions` row).
  • dreyv_marketplace_listings_submitscope: publish:marketplaceSubmit a draft (or suspended) listing for reviewTransitions draft|suspended → pending. Idempotent on pending.
  • dreyv_marketplace_listings_publishscope: publish:marketplaceSelf-serve publish a draft or pending listingValidates capability kind manifests require `manifest.bindings`. Fires `marketplace.listing_published`.
  • dreyv_marketplace_listings_unpublishscope: publish:marketplaceRevert a published listing to draftSets `unpublished_at = now()` and fires `marketplace.listing_unpublished`. Installs are preserved but new installs blocked.
  • dreyv_marketplace_listings_getscope: read:marketplaceFetch a listing by id or (publisherSlug, listingSlug)Returns listing + publisher + caller's install row. Drafts are only visible to the owner. Pass `id`, OR both `publisherSlug` and `listingSlug`.
  • dreyv_marketplace_listings_searchscope: read:marketplaceBrowse the public catalog with filters and sortPublic-by-default search across published listings. `includeUnpublished:true` scopes to caller's own drafts.
  • dreyv_marketplace_listings_versions_listscope: read:marketplaceList immutable version history for a listingReturns version, changelog, manifest hash, yank status. Manifest body itself is not echoed (fetch via listings_get as owner).
  • dreyv_marketplace_listings_installscope: write:marketplaceInstall a listing for the callerCreates (or reactivates) an install row pinned to the current published version. Paid listings require `acceptPaid:true`. Fires `marketplace.listing_installed` to both installer and publisher.
  • dreyv_marketplace_listings_uninstallscope: write:marketplaceUninstall a previously installed listingSets install.status=uninstalled, decrements installCount (floored at 0), fires `marketplace.listing_uninstalled`.
  • dreyv_marketplace_installs_listscope: read:marketplaceList the caller's installs (active by default)Joins listing title/slug/kind/currentVersion. Supports status filter.
  • dreyv_marketplace_reviews_upsertscope: write:marketplaceCreate or update the caller's review on a listingVerified-purchase only (install required). Owners cannot review their own listings. Recomputes listing rating aggregate. Fires `marketplace.review_posted` on first create.
  • dreyv_marketplace_reviews_listscope: read:marketplaceList public (non-hidden) reviews on a listingPaginated, most-recent first. Hidden/moderated reviews are excluded.
  • dreyv_marketplace_reviews_deletescope: write:marketplaceDelete the caller's own reviewHard-deletes and recomputes the listing rating aggregate.
  • dreyv_marketplace_policyscope: read:marketplaceTier limits, allowed enums, webhook eventsReturns per-tier caps (maxListings, maxVersionsPerListing, maxInstalls, maxReviewsPerDay, paidListingsAllowed), enum vocabularies, slug/semver regexes, and the webhook event list.
  • dreyv_sla_pages_createscope: publish:slaCreate a new status pageCreates an owner-private status page. Slug must be globally unique, kebab-case, 1–64 chars. Custom branding requires Mini+ tier.
  • dreyv_sla_pages_updatescope: publish:slaUpdate status page metadata, branding, components, or visibilityOwner-only partial update. Toggling isPublic does not stamp publishedAt — use sla.pages_publish for that.
  • dreyv_sla_pages_publishscope: publish:slaMark a status page public and stamp publishedAtOnce published, anonymous visitors can view the page and its incidents/maintenance via the public read API.
  • dreyv_sla_pages_unpublishscope: publish:slaHide a status page from public accessSets isPublic=false. publishedAt is preserved as the original publish stamp.
  • dreyv_sla_pages_getscope: read:slaFetch a status page by id or slug (owner view)Returns the owner's full page record. For the unauthenticated public view, use the public /status/{slug} route. Provide either `id` or `slug`.
  • dreyv_sla_pages_listscope: read:slaList the caller's status pagesNewest-first list of pages owned by the caller.
  • dreyv_sla_pages_deletescope: publish:slaHard-delete a status page and all dependent recordsCascades to incidents, updates, maintenance windows, and subscribers. Cannot be undone.
  • dreyv_sla_incidents_openscope: write:slaOpen a new incident on a status pageCreates an incident in `investigating` status. Optionally posts the first update body atomically. Counts against the per-tier monthly incident quota.
  • dreyv_sla_incidents_updatescope: write:slaPost a status update on an open incidentAdds a timeline entry, transitions the incident status, and stamps resolvedAt when status='resolved'. Emits `status.incident_updated` (or `status.incident_resolved`).
  • dreyv_sla_incidents_listscope: read:slaList incidents owned by the callerNewest-first by startedAt. Filter by pageId and/or status.
  • dreyv_sla_incidents_getscope: read:slaFetch a single incident with its full update timelineReturns the incident record plus its updates in reverse-chronological order.
  • dreyv_sla_maintenance_schedulescope: write:slaSchedule a maintenance windowPosts a future maintenance window. scheduledEnd must be after scheduledStart. Emits `status.maintenance_scheduled`.
  • dreyv_sla_maintenance_updatescope: write:slaUpdate a maintenance window (status, title, timings)Transitioning status to in_progress or completed emits matching webhook events.
  • dreyv_sla_maintenance_listscope: read:slaList maintenance windows owned by the callerNewest-first by scheduledStart. Filter by pageId and/or status.
  • dreyv_sla_maintenance_cancelscope: write:slaCancel a scheduled maintenance windowSets status=cancelled. Does not delete the record.
  • dreyv_sla_subscribers_addscope: write:slaAdd an email or webhook subscriber to a status pageMints a single-use confirm token. autoConfirm=true is permitted only because the caller is the page owner — set it false to require email/webhook confirmation.
  • dreyv_sla_subscribers_confirmscope: write:slaConfirm a subscriber with the mailed/posted tokenIdempotent — re-confirming an already-confirmed subscriber is a no-op.
  • dreyv_sla_subscribers_listscope: read:slaList subscribers on one of the caller's status pagesOwner-only. Defaults to active (non-unsubscribed) subscribers.
  • dreyv_sla_subscribers_removescope: write:slaUnsubscribe a subscriber (soft delete)Stamps unsubscribedAt; record is retained for audit. Re-adding the same (channel,target) requires a fresh add call.
  • dreyv_sla_targets_listscope: read:slaList SLA targets visible to the caller plus tier defaultsReturns user-specific overrides, global defaults, the caller's tier, and the canonical default-target row for that tier.
  • dreyv_sla_credits_computescope: write:slaCompute and upsert an SLA credit ledger entry for a periodCompares observed uptime against the caller's tier target. Emits `sla.credit_issued` when credit > 0. Upserts on (user, periodMonth).
  • dreyv_sla_credits_listscope: read:slaList the caller's SLA credit ledgerNewest-first by createdAt. Statuses: pending, approved, paid, denied.
  • dreyv_sla_policyscope: read:slaTier limits, allowed enums, credit schedule, webhook eventsReturns the caller's tier, per-tier caps (maxPages, maxIncidentsPerMonth, maxSubscribersPerPage, allowCustomBranding), default SLA targets per tier, enum vocabularies, the SLA credit schedule (gap → credit%), slug/period regexes, and the webhook event list.
  • dreyv_schemas_registerscope: publish:contractsRegister a new schema version (creates the schema on first call)Stores an immutable schema version under (namespace, name). Version must strictly increase by semver. Auto-computes compatibility (`backward` if no breaking changes) and a breaking-change diff vs the previous latest. Emits `schema.registered` on first version and `schema.version_published` on every version.
  • dreyv_schemas_listscope: read:contractsList schemas owned by the callerNewest-updated first. Excludes deprecated schemas unless `includeDeprecated` is true.
  • dreyv_schemas_getscope: read:contractsFetch a schema and one of its versionsLook up by id OR (namespace,name). When `version` is omitted, returns the schema's latest version.
  • dreyv_schemas_versions_listscope: read:contractsList versions of a schemaNewest-first by createdAt. Includes yank metadata.
  • dreyv_schemas_deprecatescope: publish:contractsMark a schema as deprecatedSets `deprecatedAt` on the schema. Existing contracts continue to validate but the schema is hidden from default lists. Emits `schema.deprecated`.
  • dreyv_schemas_yank_versionscope: publish:contractsYank a single schema version (soft-disable)Stamps `yankedAt` and `yankReason`. The row remains for audit; downstream contracts pinned to that version should be migrated.
  • dreyv_schemas_validatescope: read:contractsValidate a payload against a specific schema versionReturns `{ valid, errors[] }`. Errors include JSON-pointer-like paths, keyword, and message. Defaults to the schema's latest version.
  • dreyv_schemas_diffscope: read:contractsDiff two versions of a schemaReturns all field-level changes plus a `breakingChanges` filter and resulting `compatibility` level. Breaking = required_added, type_changed, enum_value_removed, constraint_tightened, pattern_changed, additional_properties tightening, items_changed (non-object).
  • dreyv_schemas_compatibility_checkscope: read:contractsDry-run compatibility check for a candidate schemaLike `schemas.diff` but the new side is a draft schema not yet stored. Use in CI to gate breaking changes before calling `schemas.register`.
  • dreyv_contracts_createscope: write:contractsBind a schema version to a runtime subject (event / capability / endpoint)Creates a validation contract. `mode='validate'` is read-only; `warn` records a `warn` violation; `enforce` records `error` and surfaces `enforced=true` to callers. Emits `contract.created`.
  • dreyv_contracts_updatescope: write:contractsUpdate a contract's pinned version, mode, or active flagPartial update. Switching `schemaVersion` requires the version to exist on the bound schema. Emits `contract.updated`.
  • dreyv_contracts_listscope: read:contractsList the caller's contractsFilter by subjectType / subject / activeOnly. Newest-updated first.
  • dreyv_contracts_getscope: read:contractsFetch a contract by idOwner-only.
  • dreyv_contracts_deletescope: write:contractsDelete a contract (cascades violation log)Hard delete. Emits `contract.deleted`.
  • dreyv_contracts_validatescope: read:contractsValidate a payload against a resolved contractResolve the contract by id, name, or active (subjectType,subject). Records a violation when invalid and the contract mode is `warn`/`enforce` (or `recordViolation=true` is passed). Emits `contract.violation` on recorded violations.
  • dreyv_contracts_violations_listscope: read:contractsList recent contract violationsNewest-first. Filter by contractId. Each row includes an excerpted payload (cap 2 KiB) and the error list.
  • dreyv_contracts_policyscope: read:contractsTier limits, supported JSON-Schema keywords, diff semantics, eventsReturns per-tier caps (maxSchemas, maxVersionsPerSchema, maxContracts, maxViolationsRetained, maxSchemaBytes), enum vocabularies, semver/name regexes, the supported JSON-Schema keyword subset, the breaking-change classification table, and the webhook event list.
  • dreyv_obs_trace_ingestscope: write:obsIngest an OTel-style trace (1 trace, N spans)Stores a trace and all spans atomically. Idempotent on (userId, traceId): re-ingesting updates the trace summary and adds any missing spans.
  • dreyv_obs_trace_listscope: read:obsList recent tracesNewest-first. Filter by service or status.
  • dreyv_obs_span_listscope: read:obsList spans for a trace (ordered by start time)Returns every span tied to the trace, ordered by `startNs` ascending.
  • dreyv_obs_metric_ingestscope: write:obsIngest a batch of metric points (counter/gauge/histogram)Up to 5000 points per call. Labels are arbitrary JSON.
  • dreyv_obs_metric_queryscope: read:obsQuery metric points and aggregate stats over a windowReturns raw points plus min/max/avg/last summary. Default window is the last 24h.
  • dreyv_audit_appendscope: write:auditAppend a tamper-evident entry to the audit chainEach entry is sha256-hashed and chains to the previous entry's hash. Use `audit.verify` to validate the chain.
  • dreyv_audit_listscope: read:auditList recent audit entriesNewest-first by seq. Filter by action.
  • dreyv_audit_verifyscope: read:auditVerify the full audit chain for the callerWalks every entry, recomputes hashes, and reports any broken links (seq gaps, prev-hash mismatches, hash mismatches).
  • dreyv_audit_evidence_bundlescope: read:auditGenerate a signed evidence bundle (SOC2 / GDPR / generic)Returns a JSON bundle of entries within the window plus a sha256 `bundleHash` you can publish or notarize.
  • dreyv_limits_policy_createscope: write:limitsCreate a rate-limit policy (per key, user, route, or IP)Defines `limitCount` requests per `windowSec` with optional `burst`. `action` chooses what happens on overflow: `throttle`, `reject`, or `log`.
  • dreyv_limits_policy_listscope: read:limitsList rate-limit policiesNewest-updated first.
  • dreyv_limits_policy_updatescope: write:limitsUpdate a rate-limit policy (partial)Patch `enabled`, `limitCount`, `windowSec`, `burst`, or `action`.
  • dreyv_limits_policy_deletescope: write:limitsDelete a rate-limit policyCascades to its usage rows.
  • dreyv_limits_checkscope: write:limitsCheck & consume a rate-limit bucketAtomically increments the bucket if allowed, returns `{ allowed, limit, remaining, resetAt }`. Buckets are aligned to fixed windows.
  • dreyv_limits_usagescope: read:limitsRecent usage rows for a policyNewest-first.
  • dreyv_regions_listscope: read:residencyList supported regionsStatic catalog of region codes you can pin resources to.
  • dreyv_residency_policy_getscope: read:residencyGet the caller's residency policyReturns the default region, allowed-region list, and strict-mode flag. Returns sensible defaults (with `inherited:true`) if no policy is set.
  • dreyv_residency_policy_setscope: write:residencySet the caller's residency policyValidates regions against the supported list. `defaultRegion` must be in `allowedRegions`. Upserts in place.
  • dreyv_residency_pinscope: write:residencyPin a resource to a specific regionRefuses regions not in the caller's `allowedRegions`. Idempotent on (resourceType, resourceId).
  • dreyv_residency_pin_listscope: read:residencyList pinned resourcesFilter by `resourceType` and/or `region`.
  • dreyv_digests_channel_createscope: write:digestsCreate a digest channel (slack / telegram / email / webhook)Stores the channel target plus optional quiet-hours window (`HH:MM` UTC). Use a `secretRef` to point at a stored signing token instead of inlining secrets.
  • dreyv_digests_channel_listscope: read:digestsList digest channelsFilter by `kind` or `enabled` state.
  • dreyv_digests_channel_deletescope: write:digestsDelete a digest channelSchedules referencing the channel will skip it on next run.
  • dreyv_digests_schedule_createscope: write:digestsCreate a digest schedule (cron → channels)Validates that all `channelIds` belong to the caller and that `cron` has 5 fields. The runner picks up the next-due schedule.
  • dreyv_digests_schedule_listscope: read:digestsList digest schedulesNewest-updated first.
  • dreyv_digests_send_nowscope: write:digestsSend an immediate digest to a single channelRespects quiet hours. Records the send intent in the audit log so delivery is traceable.
  • dreyv_search_indexscope: write:searchIndex (or update) a document for cross-entity searchIdempotent on (entityType, entityId). Postgres builds the tsvector automatically with A/B weighting (title vs body).
  • dreyv_search_queryscope: read:searchFull-text search across indexed entitiesUses Postgres `plainto_tsquery` ranking. Optionally scope to a single `entityType`.
  • dreyv_search_saved_createscope: write:searchCreate or update a saved searchUpserts on (userId, name). `pinned` controls list ordering.
  • dreyv_search_saved_listscope: read:searchList saved searches (pinned first)Pinned entries appear first, then by most recently updated.
  • dreyv_search_saved_deletescope: write:searchDelete a saved searchHard delete.
  • dreyv_workflows_createscope: write:workflowsCreate a workflow (trigger → DAG of nodes)Validates the DAG: unique node ids, all `next` refs resolved, no cycles, ≤100 nodes. Node `kind` ∈ {capability, branch, delay, noop}.
  • dreyv_workflows_listscope: read:workflowsList workflowsNewest-updated first.
  • dreyv_workflows_getscope: read:workflowsGet a workflow by idReturns the full definition (trigger + nodes).
  • dreyv_workflows_deletescope: write:workflowsDelete a workflowCascades to runs.
  • dreyv_workflows_runscope: write:workflowsExecute a workflow (topological order, records a run)Topologically orders nodes, executes them, and stores a `workflow_run` row with per-node log. Capability nodes are queued (not executed inline) so long fan-outs don't block the API call; pass `dryRun:true` to only validate the plan.
  • dreyv_workflows_runs_listscope: read:workflowsList recent workflow runsNewest-first. Filter by `workflowId` and/or `status`.
  • dreyv_entitlements_listscope: read:entitlementsList every feature, its plan value, and active overrideReturns the caller's tier plus a per-feature breakdown: `planValue`, `override`, `effectiveValue`, `source`.
  • dreyv_entitlements_checkscope: read:entitlementsCheck whether a feature is allowed (optionally with a requested numeric value)For boolean features, returns the value. For numeric features, returns `allowed = requestedValue ≤ effectiveValue`.
  • dreyv_entitlements_override_setscope: write:entitlementsSet or update an entitlement override (optionally time-boxed)Upserts on (userId, feature). `value` can be boolean, number, string, or object. `expiresAt` makes the override temporary.
  • dreyv_entitlements_override_listscope: read:entitlementsList active entitlement overridesNewest-updated first. Expired overrides remain visible so you can clean them up.
  • dreyv_entitlements_override_deletescope: write:entitlementsDelete an entitlement overrideSubsequent checks fall back to the plan value.
  • dreyv_meta_versionscope: read:statusDreyv MCP server version, tool/pillar counts, and schema metadata[META] Returns server name + semver, MCP protocol schema version, total tool count, pillar count, scope list, and a sideEffect breakdown (read / unsigned-tx / write / pay). Call this first to know what you're connected to. Includes links to OpenAPI, manifest, REST base, and changelog.
  • dreyv_meta_capabilities_overviewscope: read:status300+ tools mapped to 39 pillars with execution-label tallies[META] Compact map of every tool grouped by pillar, each tagged with executionLabel (READ / UNSIGNED-TX / WRITE / PAY) so agents know what each call will do before invoking. Filter by pillar or executionLabel to narrow. Safer than tools/list for first-pass discovery.
  • dreyv_meta_intents_howtoscope: read:statusEnd-to-end execution playbooks (swap, intents, stake, autonomous pay)[META] Step-by-step flows for the four execution paths: Jupiter swap, persistent compile→sign→submit intent (multisig-friendly), Marinade SOL stake, and autonomous SKU purchase via dreyv_economy_pay. Includes the non-custodial signing model, preflight tips, and structured error semantics.
  • dreyv_meta_instructionsscope: read:statusServer orientation text (custody model, tool tags, discovery)[META] Returns the same orientation block we'd return in MCP `initialize.instructions` if the transport supported it: who we are, the [READ]/[UNSIGNED-TX]/[WRITE]/[PAY] tag system, how to discover, how to authenticate.
  • dreyv_intents_deeplinksscope: read:statusGenerate one-tap sign deeplinks (Phantom / Solflare / Backpack) + QR for any base64 tx[READ] Given an unsigned base64 Solana tx, returns universal-link URLs for Phantom, Solflare, and Backpack plus a QR-ready Solana Pay payload and a mobile-handoff URL pointing at /mobile/signer. Stages the tx server-side under a short-lived handoff id so wallets can fetch it via Solana Pay transaction-request. Use this whenever you've produced an unsigned tx (compile, swap_tx, stake_tx, custom) and want the user to sign in one tap on desktop OR mobile.
  • dreyv_intents_handoff_qrscope: read:statusStage a tx for QR handoff to the user's mobile wallet[READ] Same as dreyv_intents_deeplinks but with explicit TTL control and instructions tuned for desktop→phone handoff. Returns qrSvgDataUri (display directly in chat / a panel), mobileHandoffUrl (fallback link), and a Solana Pay payload. After the user signs, poll GET /api/mcp/handoff/{handoffId} to observe completion.
  • dreyv_intents_handoff_statusscope: read:statusCheck whether the user has signed a staged handoff (and on-chain confirmation)[READ] Native MCP replacement for raw `GET /api/mcp/handoff/{id}` polling. Given a `handoffId` returned by dreyv_intents_deeplinks / dreyv_intents_handoff_qr / dreyv_defi_swap / any other UNSIGNED-TX tool, returns `{ status: 'pending'|'signed'|'rejected'|'expired'|'not_found', signature, onChain: { confirmationStatus, slot, err }, explorerUrl, secondsRemaining }`. When `status === 'signed'`, by default also fetches the Solana RPC signature status so the agent can report 'confirmed' / 'finalized' without a second tool. Poll every 2–5s after presenting a QR / deeplink. Stop polling on any terminal status.
  • dreyv_session_signer_createscope: agent:delegateMint an ephemeral, capped Solana signer the agent can use without prompting the user wallet[WRITE] Generates a short-lived Ed25519 keypair held only in this MCP session's memory and bound to this API key. The user funds the returned public key with the SOL they're willing to delegate, then the agent calls dreyv_session_signer_sign for autonomous signing within strict caps (maxLamports cumulative, maxTxCount, allowedProgramIds whitelist, TTL). Use for short bursts of agent activity (e.g. a 1-hour rebalance session) without round-tripping every signature. Non-custodial — Dreyv does NOT touch the user's main wallet.
  • dreyv_session_signer_signscope: agent:delegateSign a base64 tx with an active session signer, enforcing caps[WRITE] Signs the supplied tx with the session signer. Rejects with a structured error if: session expired/revoked, tx count cap hit, lamports cap would be exceeded (pass estimatedLamportsOut), or any instruction targets a program not on the whitelist. Returns signedTxBase64 and signature — caller is still responsible for broadcasting via dreyv_intents_submit or sendRawTransaction.
  • dreyv_session_signer_statusscope: read:statusGet current usage + caps + remaining budget for a session signer[READ] Returns the session record minus the secret key — caps, usage (txCount, spentLamports), status, expiresAt.
  • dreyv_session_signer_revokescope: agent:delegateDestroy a session signer immediately[WRITE] Marks the session revoked and drops the secret key from memory. Idempotent. Sweep any remaining SOL on the public key back to your main wallet BEFORE revoking.
  • dreyv_colosseum_searchscope: read:marketSearch the Solana builder ecosystem (Colosseum Copilot)[READ] Search Colosseum's index of Solana hackathon projects, accelerator companies, and active builders. Returns name, summary, tags, score. Cached 24h.
  • dreyv_colosseum_projectscope: read:marketFull Colosseum project profile (team, hackathon, funding, links)[READ] Full project profile from Colosseum: hackathon track, cohort, team/founders, funding stage, social/github/website links. Falls back to top-hit search when an exact slug isn't found.
  • dreyv_colosseum_similarscope: read:marketProjects similar to a given Solana project[READ] Ranked list of Colosseum projects similar to the input slug. Useful for competitor discovery, Foresight rotation suggestions, and 'builders in this space' surfaces.

Transport notes

The dreyv MCP server speaks Streamable HTTP per the MCP spec. POST requests must include Accept: application/json, text/event-stream. Rate limits, scope enforcement and per-key usage metering are identical to the REST surface. Both transports share the same typed capability registry.