{ "meta": { "attribution": "Anchor Terminal (https://www.anchorterminal.com)", "docs": "https://www.anchorterminal.com/docs/", "generatedAt": "2026-10-04", "license": "CC-BY-4.0", "method": "https://www.anchorterminal.com/benchmark/", "methodology": "0.3", "openapi": "https://www.anchorterminal.com/openapi.json", "preview": false, "run": "2026-10-01", "runLabel": "October 2026 research run" }, "tool": { "category": "commerce", "endpoint": "https://vaaya.ai/mcp", "jsonUrl": "https://www.anchorterminal.com/api/v1/tools/vaaya-mcp.json", "kind": "mcp", "listed": "indexed", "liveUrl": "https://www.anchorterminal.com/api/v1/live/vaaya-mcp.json", "markdownUrl": "https://www.anchorterminal.com/tools/vaaya-mcp.md", "mcpTools": { "check": { "checker": "anchor-check/1.0", "totalTokens": 9712, "counts": { "error": 0, "note": 0, "warn": 5 }, "findings": [ { "rule": "TC07", "severity": "warn", "tool": "buy", "message": "the description is about 1,106 tokens", "fix": "Keep the description to what a model needs to choose and call the tool; move the manual to a resource or the docs." }, { "rule": "TC13", "severity": "warn", "tool": "buy", "message": "params (object with no properties)", "fix": "Declare the properties (or additionalProperties with a schema) and the array's items." }, { "rule": "TC13", "severity": "warn", "tool": "use", "message": "params (object with no properties)", "fix": "Declare the properties (or additionalProperties with a schema) and the array's items." }, { "rule": "TC15", "severity": "warn", "tool": "buy", "message": "inputSchema uses $ref/$defs", "fix": "Inline the referenced schemas. Pydantic and zod-to-json-schema emit $defs for nested models; most can be told not to." }, { "rule": "TC22", "severity": "warn", "tool": "buy", "message": "the definition is about 3,391 tokens", "fix": "Trim the description and parameter docs, or split the tool." } ] }, "checkedAt": "2026-10-04T22:20:57Z", "count": 13, "note": "answered without the initialize handshake", "schemaTokens": 9712, "status": "ok", "tools": [ { "name": "stocks", "title": "Buy Tokenized Stocks", "description": "Buy tokenized stocks on Base using only the user’s prepaid Vaaya balance, never the welcome credit or the GitHub credit line. Commands: list (supported token tickers), portfolio (owned stocks and buying power), quote {symbol, amount_cents}, buy {symbol, amount_cents, idempotency_key}, order {order_id}. When the user asks to buy a specified stock and dollar amount, resolve its supported token ticker (Apple = AAPLc) and call buy directly; no activation or additional approval step. amount_cents is the maximum total prepaid spend including provider fees. Use a unique idempotency_key for each intended purchase and reuse it on retries. Query order until confirmed/failed; queued/submitted is not success. Do not increase the user’s spend or retry a failed purchase as a new order without instruction. Ask only for missing or ambiguous purchase details. If prepaid_required or buyingPowerCents is insufficient, offer a $14/$40/$60 prepaid pack: POST /api/v1/topup with pack_cents 1400/4000/6000 and the same account bearer token returns a Stripe Checkout url. With authorization for that pack amount, the user’s Instinct agent can pay the URL in its browser using the card saved in Instinct; otherwise give the URL to the user. Vaaya cannot charge Instinct’s card directly. Do not include card details or tokens in a handoff. Check GET /api/v1/wallet wallet.prepaid_cents, then portfolio buyingPowerCents before resuming the same purchase key. A share purchase alone does not authorize a top-up. Stop on needs_review as well as failed.", "inputSchema": { "additionalProperties": false, "properties": { "amount_cents": { "description": "Maximum prepaid spend in cents, pool fees included. Required for quote and buy.", "maximum": 1000000, "minimum": 100, "type": "integer" }, "command": { "description": "list (supported tickers), portfolio (holdings + buying power), quote, buy, or order (status by id).", "enum": [ "list", "portfolio", "quote", "buy", "order" ], "type": "string" }, "idempotency_key": { "description": "Unique per intended purchase; reuse it on retries. Required for buy.", "maxLength": 128, "minLength": 8, "type": "string" }, "order_id": { "description": "Order id returned by buy. Required for order.", "type": "string" }, "symbol": { "description": "Token ticker from list, e.g. AAPLc. Required for quote and buy.", "type": "string" } }, "required": [ "command" ], "type": "object" }, "outputSchema": { "additionalProperties": true, "properties": { "address": { "description": "portfolio: the user stock wallet on Base.", "type": "string" }, "amountCents": { "description": "Prepaid cents reserved for the purchase.", "type": "number" }, "buyingPowerCents": { "description": "portfolio: prepaid cents available for stocks.", "type": "number" }, "chargedCents": { "description": "buy/order: cents actually charged once confirmed.", "type": "number" }, "error": { "description": "Error code/message when ok=false.", "type": "string" }, "estimatedTokens": { "description": "quote: expected token amount.", "type": "string" }, "expiresAt": { "description": "quote: ISO 8601 expiry (60s).", "type": "string" }, "funding": { "description": "list: always prepaid_only.", "type": "string" }, "holdings": { "description": "portfolio: per-stock tokens, shares, valueUsd and staleness.", "type": "array" }, "id": { "description": "quote/buy/order: quote id or order id.", "type": "string" }, "message": { "description": "Human-readable failure detail.", "type": "string" }, "minimumTokens": { "description": "quote: guaranteed minimum after 50 bps slippage.", "type": "string" }, "orders": { "description": "portfolio: recent orders.", "type": "array" }, "status": { "description": "buy/order: queued | approving | ready | submitted | confirmed | failed | needs_review.", "type": "string" }, "stocks": { "description": "list: supported stocks with symbol, name, address, priceUsd and staleness.", "type": "array" }, "symbol": { "description": "Token ticker, e.g. AAPLc.", "type": "string" }, "tokens": { "description": "buy/order: tokens delivered once confirmed.", "type": "string" }, "totalValueUsd": { "description": "portfolio: holdings value at the latest feed price.", "type": "string" }, "txHash": { "description": "buy/order: Base transaction hash once broadcast.", "type": "string" } }, "type": "object" }, "annotations": { "destructiveHint": false, "idempotentHint": false, "openWorldHint": true, "readOnlyHint": false, "title": "Buy Tokenized Stocks" } }, { "name": "vaaya_test_connection", "title": "Test Vaaya Connection", "description": "Round-trip ping that confirms the agent → Vaaya connection and whether the user is linked. Returns { ok:true, userId, scope, version, server_time, first_call } when linked — SHOW `first_call.show_to_user` to the user as written, it is the same set of starter examples the website and installer give them. Returns { ok:false, needs_auth:true, verification_uri, signup_uri, instructions } when not linked yet — relay that to the user so they can connect (and sign up if new).", "inputSchema": { "properties": {}, "type": "object" }, "outputSchema": { "additionalProperties": true, "properties": { "instructions": { "description": "What to tell the user to get connected.", "type": "string" }, "needs_auth": { "description": "True when this agent is not linked to a Vaaya user yet.", "type": "boolean" }, "ok": { "description": "True when the agent is linked to a Vaaya user.", "type": "boolean" }, "scope": { "description": "Space-separated authorized scopes.", "type": "string" }, "server_time": { "description": "Server time, ISO 8601.", "type": "string" }, "signup_uri": { "description": "Where a new user signs up.", "type": "string" }, "userId": { "description": "Linked Vaaya user id.", "type": "string" }, "verification_uri": { "description": "Where the user approves the connection.", "type": "string" }, "version": { "description": "Server version.", "type": "string" } }, "type": "object" }, "annotations": { "destructiveHint": false, "idempotentHint": true, "openWorldHint": false, "readOnlyHint": true, "title": "Test Vaaya Connection" } }, { "name": "vaaya_onboard", "title": "Get Onboarding Instructions", "description": "Public onboarding hint for an agent whose user isn't linked to Vaaya yet. Returns where the human should go to connect (and sign up if new). Call this when vaaya_test_connection reports needs_auth, or any tool returns unauthorized, then relay the instructions to the user. If the user IS already linked it returns `first_call` instead — show `first_call.show_to_user` as written so they know what to try.", "inputSchema": { "properties": {}, "type": "object" }, "outputSchema": { "additionalProperties": true, "properties": { "already_linked": { "description": "True when the agent is already connected.", "type": "boolean" }, "instructions": { "description": "What to tell the user to get connected.", "type": "string" }, "message": { "description": "Status message to relay to the user.", "type": "string" }, "needs_auth": { "description": "True when this agent is not linked to a Vaaya user yet.", "type": "boolean" }, "signup_uri": { "description": "Where a new user signs up.", "type": "string" }, "verification_uri": { "description": "Where the user approves the connection.", "type": "string" } }, "type": "object" }, "annotations": { "destructiveHint": false, "idempotentHint": true, "openWorldHint": false, "readOnlyHint": true, "title": "Get Onboarding Instructions" } }, { "name": "vaaya_account", "title": "Show Connected Account \u0026 Balance", "description": "Show which Vaaya account this connection is linked to and its money state. Returns { email, name, user_id, connected_client, scopes, balance_cents, credit_line, available_cents, credits_url, switch_account }. Call it whenever the user asks \"which account is connected\", \"what's my balance\", \"how much credit is left\", or \"how do I switch accounts\" — and relay the answer. `credit_line` is the credit the account can spend past its prepaid balance (the welcome credit plus any GitHub-score line); `available_cents` = balance + active line, the number calls are gated on.", "inputSchema": { "properties": {}, "type": "object" }, "outputSchema": { "additionalProperties": true, "properties": { "balance_cents": { "description": "Wallet balance remaining, in cents.", "type": "number" }, "connected_client": { "description": "OAuth client name this connection was made through.", "type": "string" }, "credits_url": { "description": "Where the user buys credit packs.", "type": "string" }, "email": { "description": "Email of the connected Vaaya account.", "type": "string" }, "instructions": { "description": "What to tell the user to get connected.", "type": "string" }, "name": { "description": "Display name of the connected user.", "type": "string" }, "needs_auth": { "description": "True when this agent is not linked to a Vaaya user yet.", "type": "boolean" }, "ok": { "description": "True when the call succeeded.", "type": "boolean" }, "premium_allowance": { "description": "Gated free-tier state for premium services: cap, purchased, spent, remaining (cents). Separate from wallet balance.", "type": "object" }, "scopes": { "description": "Authorized scopes for this connection.", "type": "array" }, "signup_uri": { "description": "Where a new user signs up.", "type": "string" }, "switch_account": { "description": "How to connect a different account — relay to the user.", "type": "string" }, "user_id": { "description": "Vaaya user id.", "type": "string" }, "verification_uri": { "description": "Where the user approves the connection.", "type": "string" } }, "type": "object" }, "annotations": { "destructiveHint": false, "idempotentHint": true, "openWorldHint": false, "readOnlyHint": true, "title": "Show Connected Account \u0026 Balance" } }, { "name": "vaaya_logout", "title": "Disconnect / Switch Vaaya Account", "description": "Disconnect this client from the current Vaaya account: revokes this connection's authorization server-side, so every later call fails with 401 until the user reconnects. Call it when the user asks to log out, sign out, disconnect, or switch Vaaya accounts — then relay the returned switch steps VERBATIM (the browser sign-out step is what actually enables switching accounts).", "inputSchema": { "properties": {}, "type": "object" }, "outputSchema": { "additionalProperties": true, "properties": { "error": { "description": "Error code/message when ok=false.", "type": "string" }, "logged_out": { "description": "True when the authorization was revoked.", "type": "boolean" }, "message": { "description": "What happened — relay to the user.", "type": "string" }, "ok": { "description": "True when the call succeeded.", "type": "boolean" }, "to_switch_account": { "description": "Exact steps to reconnect with a different account — relay verbatim.", "type": "string" } }, "type": "object" }, "annotations": { "destructiveHint": true, "idempotentHint": true, "openWorldHint": false, "readOnlyHint": false, "title": "Disconnect / Switch Vaaya Account" } }, { "name": "docs", "title": "Read Vaaya Deep Reference", "description": "Vaaya's deep reference, FREE and instant. Pass `topic` to get the full playbook for a capability area — exact services, actions, params, prices, model lists, and gotchas — the same reference files the vaaya skill ships. Topics: 'setup' (connecting an agent, a chat app, or an unattended process), 'tools' (exact params of every Vaaya tool, GTM suite included), 'media' (image/video/audio models + product-demo videos), 'gtm' (leads, enrichment, outreach, signals, email), 'research' (OneSearch lanes, deep research, company/market research playbooks), 'data' (scraping, people, social platforms, public records, onchain, compliance), 'compute' (sandboxes, browser automation, files, memory, workers, phone calls, llm). Read the matching topic BEFORE non-trivial work in that area — it is cheaper than a wrong call. Never bills; safe to call any time.", "inputSchema": { "properties": { "topic": { "description": "Which reference to fetch.", "enum": [ "setup", "tools", "media", "gtm", "research", "data", "compute" ], "type": "string" } }, "required": [ "topic" ], "type": "object" }, "outputSchema": { "additionalProperties": true, "properties": { "content": { "description": "The full reference document (markdown).", "type": "string" }, "error": { "description": "Set when the topic is unknown.", "type": "string" }, "ok": { "description": "True when the call succeeded.", "type": "boolean" }, "topic": { "description": "The topic served.", "type": "string" }, "topics": { "description": "Valid topics, returned on an unknown-topic error.", "type": "array" } }, "type": "object" }, "annotations": { "destructiveHint": false, "idempotentHint": true, "openWorldHint": false, "readOnlyHint": true, "title": "Read Vaaya Deep Reference" } }, { "name": "consult", "title": "Consult Vaaya — Plan Any Capability", "description": "Vaaya's consultant. Describe ANY external capability you or the user might want — generate an image/video, search or scrape the web, run code in a sandbox, send/receive email, enrich a contact — and it helps figure out the best way, teaching the user what Vaaya can do. It is CONVERSATIONAL and remembers prior turns. It returns: mode='converse' (a reply to RELAY to the user verbatim — questions, options, ideas; get the user's response and call consult again with it, so the conversation continues), mode='call' (an ordered list of calls to run via `use`, with a message explaining the preferred choice + alternatives + why; multi-step results may contain placeholders like '\u003cfrom step 1: sandbox_id\u003e' — run earlier steps first and substitute), or mode='unsupported'. Every reply includes `suggestions` (2-3 things to do next) — surface these to the user. AFTER you run a `call` result's calls via `use`, call consult ONE more time with a short note on the outcome (what was produced / any failures) — it returns result-aware, Vaaya-grounded next steps to offer the user (the `call` result's `after_running` field reminds you). Call consult whenever you hit a capability gap or the user wants to know what's possible. It does NOT execute or bill — you run returned calls via `use`. ALWAYS show the user consult's `message` and `suggestions` and let them steer.", "inputSchema": { "properties": { "intent": { "description": "Plain-English description of what you want, or your answer to a previous clarify question. Be concrete — include the prompt text, URL, budget, or target the task implies.", "type": "string" } }, "required": [ "intent" ], "type": "object" }, "outputSchema": { "additionalProperties": true, "properties": { "after_running": { "description": "Reminder to call consult again with the outcome.", "type": "string" }, "calls": { "description": "Ordered list of { service, action, params, max_cost_cents, why } to run via `use`.", "type": "array" }, "if_tools_missing": { "description": "What to do when a named first-party tool (gtm_*, worker_*, …) is missing from your tool list: it was just unlocked — refresh the tool list; never improvise a fallback.", "type": "string" }, "if_use_unavailable": { "description": "What to do when the `use` tool is missing from your tool list — relay to the user.", "type": "string" }, "message": { "description": "Consultant's reply — relay to the user verbatim.", "type": "string" }, "mode": { "description": "How to proceed: relay 'converse', run 'call', or report 'unsupported'.", "enum": [ "converse", "call", "unsupported" ], "type": "string" }, "reason": { "description": "Why the request is unsupported (mode='unsupported').", "type": "string" }, "run_with": { "description": "Which tool to execute the calls with.", "type": "string" }, "suggestions": { "description": "2-3 suggested next steps to surface to the user.", "type": "array" } }, "type": "object" }, "annotations": { "destructiveHint": false, "idempotentHint": false, "openWorldHint": true, "readOnlyHint": true, "title": "Consult Vaaya — Plan Any Capability" } }, { "name": "use", "title": "Execute a Paid Service Call", "description": "Execute a single external call, and bill on success. Used for any external capability (image/video/audio generation, web search, scraping, email, document parsing, code sandbox, browser automation, embeddings, etc.). The server validates params against a registered schema and proxies to the upstream — you never pass URLs or API keys. Call it directly when you know the exact (service, action, params, max_cost_cents) — from the vaaya skill's catalog or a call you've made before; when unsure, get the call from `consult` rather than guessing.", "inputSchema": { "properties": { "action": { "description": "Action within the service (e.g. \"search\", \"generate\", \"create_session\"), taken from the call `consult` returned.", "type": "string" }, "intent": { "description": "Optional: the one-line `why` from the consult call you're running (or the user's goal for it). Used only for internal transaction visibility — it never affects validation, billing, or execution. Pass it through when you have it.", "type": "string" }, "max_cost_cents": { "description": "Hard ceiling in cents on what you will be charged. `use` refuses if the registry price exceeds this. Pick at least 2× the listed price so retries work.", "type": "number" }, "params": { "additionalProperties": true, "description": "Parameters from the call `consult` returned, validated against the service's registered schema.", "type": "object" }, "service": { "description": "Service identifier, taken verbatim from the call `consult` returned.", "type": "string" } }, "required": [ "service", "action", "params", "max_cost_cents" ], "type": "object" }, "outputSchema": { "additionalProperties": true, "properties": { "async": { "description": "True when the job runs asynchronously — poll with `result`.", "type": "boolean" }, "balance_remaining_cents": { "description": "Wallet balance remaining, in cents.", "type": "number" }, "card_url": { "description": "Only on `error: \"card_required\"`: a short-lived sign-in link where the user adds a card. Relay `data.message` to the user verbatim, then retry the same call once they have.", "type": "string" }, "charged_cents": { "description": "Amount billed for this call, in cents.", "type": "number" }, "data": { "description": "Upstream result payload (URLs, text, ids, …)." }, "error": { "description": "Error code/message when ok=false.", "type": "string" }, "job_id": { "description": "Async job id for `result` polling.", "type": "string" }, "ok": { "description": "True when the call succeeded.", "type": "boolean" }, "protocol": { "description": "Settlement rail used (x402 / mpp / ledger).", "type": "string" }, "status": { "description": "Upstream HTTP status when the call failed.", "type": "number" }, "transaction_id": { "description": "Vaaya transaction id for this call.", "type": "string" } }, "type": "object" }, "annotations": { "destructiveHint": false, "idempotentHint": false, "openWorldHint": true, "readOnlyHint": false, "title": "Execute a Paid Service Call" } }, { "name": "result", "title": "Poll an Async Job", "description": "Fetch the status + output of an async job started by `use` (e.g. a video render). Pass the `job_id` that `use` returned with `{ async: true }`. Returns `{ status, result?, progress?, charged_cents }`: `running` (still working — when the job reports it, `progress` carries `{ phase, percent, rendered_frames, total_frames, eta_sec }` and `hint` is a one-line summary like \"rendering 42% (380/900 frames, ~120s left)\", so you can tell real progress from a hang; wait a bit and call again), `succeeded` (`result` holds the output, e.g. the video URL; the call is charged now), or `failed`/`cancelled` (no charge; on `failed`, read `error` AND `hint` — `hint` carries the service's usage notes, which usually explain how to fix the call). Safe to call repeatedly — it never starts new work or double-charges. ALWAYS use this to retrieve an async result instead of re-running `use` (re-running starts a new paid job).", "inputSchema": { "properties": { "job_id": { "description": "The job_id returned by an async `use` call.", "type": "string" } }, "required": [ "job_id" ], "type": "object" }, "outputSchema": { "additionalProperties": true, "properties": { "balance_remaining_cents": { "description": "Wallet balance remaining, in cents.", "type": "number" }, "charged_cents": { "description": "Amount billed for this call, in cents.", "type": "number" }, "error": { "description": "Error code/message when ok=false.", "type": "string" }, "hint": { "description": "Human-readable progress summary.", "type": "string" }, "job_id": { "description": "The polled job id.", "type": "string" }, "ok": { "description": "True when the call succeeded.", "type": "boolean" }, "progress": { "description": "Progress detail (e.g. percent) while running.", "type": "object" }, "result": { "description": "Final output when succeeded." }, "status": { "description": "Job state.", "enum": [ "running", "succeeded", "failed", "cancelled" ], "type": "string" } }, "type": "object" }, "annotations": { "destructiveHint": false, "idempotentHint": true, "openWorldHint": true, "readOnlyHint": true, "title": "Poll an Async Job" } }, { "name": "buy", "title": "Buy Something for the User", "description": "Find and buy products, tickets, bookings and subscriptions for the user at supported stores. Start with `search` { query } to find the item and merchant page using Vaaya OneSearch (5¢ per search); the user can describe what they need without supplying a link. Before checkout, use `setup` to check payment and shipping readiness; resolve missing setup once. Persistent merchant accounts are managed at /store-connections. Use store_connection_id to select an account. Passwords and verification codes belong only on the merchant page, never in chat. PRODUCT DISCOVERY: if the user describes what to buy but provides no URL, use `search` { query: \u003cproduct, variant, budget and preferred merchant if specified\u003e } to locate it under the existing tool spending permissions; do not ask them to paste a link or say search for it first. Search is not purchase authorization. Respect search fees and spending limits; if search is unavailable, explain the actual error and then ask for a link. Verify the merchant, item and variant from the result; ask only when matches are ambiguous or details cannot be verified. Never invent a product URL, final total or delivery date from a search snippet. THE SEAMLESS PATH: once the user has told you what to buy and you have the exact item, merchant page URL and total, call `purchase` { item, merchant, url, total_cents, confirmed: true, confirmation: \u003cthe user's own words\u003e } — it approves from their message (under the chat limit), starts buying in the user's cloud browser in the background and returns `message` (\"Hold on — buying it now.\"): RELAY IT, then poll `status` { approval_id } every ~10 seconds and relay its `message` when the status is completed (\"Done — …\"), requires_action (read action_required.reason for the exact blocker) or failed. If `status` says the user's shipping address is missing, ask for it and call `address` { name, line1, line2?, city, state?, postal_code, country, phone? } then `checkout` { approval_id } to resume; if merchant authentication is pending, relay handoff_url and handoff_deadline. The durable worker checks authentication and resumes the same authorized purchase automatically. Do not ask the user to send done or submit codes in chat. If the handoff expires, relay the recovery page; it does not clear order or payment uncertainty. Other sub-commands: `search` { query } (protocol merchants plus a real web search; the web half bills 5¢), `propose` { item, merchant, total_cents, url?, notes?, confirmed?, confirmation? } (creates an approval; without `confirmed` it returns an approval link the user opens — show its `message` VERBATIM), `checkout` { approval_id, params? } (buys an approved purchase; for a browser merchant it runs in the background like `purchase`). Use the user's existing authorization of the exact item and total; do not ask them to confirm twice. Ask only for missing purchase details. Nothing is ever bought without the user's yes: `checkout` refuses anything else. Use `reconcile` { approval_id } after an uncertain submission: it only inspects the existing checkout and never submits payment. For an unavailable checkout or inconclusive reconciliation, relay recovery_url and recovery_instructions from status. The user can resolve the attempt on its approval page only after checking both merchant orders and payment records. A chat statement alone does not clear the lock, and expiration does not clear it. If status or replay says purchase_resolved, never reuse checkout on that approval. When the user requests another attempt, call propose with retry_of set to that resolved ID, current item/price and no confirmed flag, then show the new approval link. Check setup browser_allowance first; a daily_browser_limit requires waiting until resets_at, not reconnecting or changing request text. For a handoff, return action_required.url and the deadline. The user fixes 2FA, CAPTCHA, payment, address or booking issues on that authenticated page and uses Return control to Vaaya; do not call checkout to bypass a pending handoff. Status polling never creates a replacement. Resume only the same approval_id; do not recreate a purchase to bypass an unresolved attempt. `charged_cents` is the Vaaya tool fee, NOT a merchant charge; read merchant_payment separately, and never infer a hold or capture from Link approval. Never open `browserbase` sessions yourself to buy something — only `buy` can.", "inputSchema": { "properties": { "approval_id": { "description": "The approval returned by purchase/propose (`status`, `checkout`).", "type": "string" }, "booking": { "$schema": "http://json-schema.org/draft-07/schema#", "anyOf": [ { "additionalProperties": false, "properties": { "baggage": { "$ref": "#/anyOf/0/properties/segments/items/properties/flightNumber" }, "changeCancellationTerms": { "$ref": "#/anyOf/0/properties/segments/items/properties/flightNumber" }, "kind": { "const": "flight", "type": "string" }, "segments": { "items": { "additionalProperties": false, "properties": { "cabin": { "$ref": "#/anyOf/0/properties/segments/items/properties/flightNumber" }, "departureDate": { "pattern": "^\\d{4}-\\d{2}-\\d{2}$", "type": "string" }, "departureTime": { "pattern": "^([01]\\d|2[0-3]):[0-5]\\d$", "type": "string" }, "destination": { "pattern": "^[A-Z]{3}$", "type": "string" }, "fare": { "$ref": "#/anyOf/0/properties/segments/items/properties/flightNumber" }, "flightNumber": { "maxLength": 500, "minLength": 1, "type": "string" }, "origin": { "pattern": "^[A-Z]{3}$", "type": "string" } }, "required": [ "origin", "destination", "departureDate", "departureTime", "flightNumber", "cabin", "fare" ], "type": "object" }, "maxItems": 8, "minItems": 1, "type": "array" }, "travelers": { "maximum": 9, "minimum": 1, "type": "integer" } }, "required": [ "kind", "travelers", "segments", "baggage", "changeCancellationTerms" ], "type": "object" }, { "additionalProperties": false, "properties": { "address": { "$ref": "#/anyOf/0/properties/segments/items/properties/flightNumber" }, "adults": { "maximum": 30, "minimum": 1, "type": "integer" }, "cancellationTerms": { "$ref": "#/anyOf/0/properties/segments/items/properties/flightNumber" }, "checkIn": { "$ref": "#/anyOf/0/properties/segments/items/properties/departureDate" }, "checkOut": { "$ref": "#/anyOf/0/properties/segments/items/properties/departureDate" }, "children": { "maximum": 30, "minimum": 0, "type": "integer" }, "kind": { "const": "hotel", "type": "string" }, "mandatoryFeesCents": { "minimum": 0, "type": "integer" }, "paymentTiming": { "enum": [ "pay_now", "pay_at_property", "deposit" ], "type": "string" }, "property": { "$ref": "#/anyOf/0/properties/segments/items/properties/flightNumber" }, "ratePlan": { "$ref": "#/anyOf/0/properties/segments/items/properties/flightNumber" }, "roomType": { "$ref": "#/anyOf/0/properties/segments/items/properties/flightNumber" }, "rooms": { "maximum": 9, "minimum": 1, "type": "integer" } }, "required": [ "kind", "property", "address", "checkIn", "checkOut", "rooms", "adults", "children", "roomType", "ratePlan", "cancellationTerms", "paymentTiming", "mandatoryFeesCents" ], "type": "object" } ], "description": "Required for Expedia flights and Booking.com hotels: exact itinerary/stay, counts, fare/room, baggage/cancellation and payment terms. These are shown for approval and cannot be substituted. Traveler identity documents are entered directly on the merchant page, never in chat. Final booking review requires the authenticated handoff page." }, "city": { "description": "City (`address`).", "type": "string" }, "command": { "description": "Use `search` to find an item with OneSearch, `purchase` to buy an authorized item, and `status` to track it.", "enum": [ "setup", "search", "purchase", "propose", "status", "checkout", "reconcile", "address", "credentials" ], "type": "string" }, "confirmation": { "description": "The user's own words approving it, verbatim (`purchase`, `propose`).", "type": "string" }, "confirmed": { "description": "true when the user has said yes to this exact item and total in the conversation (`purchase`, `propose`).", "type": "boolean" }, "country": { "description": "Two-letter country code, e.g. US (`address`).", "type": "string" }, "currency": { "description": "ISO currency, default 'usd'.", "type": "string" }, "email": { "description": "Contact email for the order; defaults to the account email (`address`).", "type": "string" }, "item": { "description": "What exactly is being bought, in the user's words — variant, size, quantity (`purchase`, `propose`).", "type": "string" }, "line1": { "description": "Street address (`address`).", "type": "string" }, "line2": { "description": "Apartment / unit (`address`).", "type": "string" }, "merchant": { "description": "Merchant host or URL, e.g. bombas.com (`purchase`, `propose`, `credentials`).", "type": "string" }, "name": { "description": "Full name for shipping (`address`).", "type": "string" }, "notes": { "description": "One line for the driver/user: variant, size, colour, quantity, delivery window.", "type": "string" }, "params": { "additionalProperties": true, "description": "The merchant's own purchase body (product id, quantity, email, shipping) for a protocol merchant (`purchase`, `checkout`).", "type": "object" }, "password": { "description": "Password at the merchant — stored encrypted, never returned (`credentials`).", "type": "string" }, "phone": { "description": "Contact phone for delivery (`address`).", "type": "string" }, "postal_code": { "description": "Postal / ZIP code (`address`).", "type": "string" }, "query": { "description": "Describe the product, variant, budget and preferred store if any. `search` uses OneSearch to find matching items and merchant pages (5¢).", "type": "string" }, "retry_of": { "description": "For propose only: the previous approval ID resolved by the owner as no order/payment. Use only when the user requests a new attempt; omit confirmed and show the fresh approval link. Never vary item text or confirmation to bypass replay or locks.", "format": "uuid", "type": "string" }, "state": { "description": "State / region (`address`).", "type": "string" }, "store_connection_id": { "description": "Merchant account connection ID from /store-connections. Required when multiple accounts are connected to the same store. Sign in and enter verification codes directly on that page, never in chat.", "type": "string" }, "total_cents": { "description": "The full total the user will pay, in cents (`purchase`, `propose`).", "type": "number" }, "url": { "description": "The exact product page the item came from — the driver starts there (`purchase`, `propose`).", "type": "string" }, "username": { "description": "Email/username at the merchant (`credentials`).", "type": "string" } }, "required": [ "command" ], "type": "object" }, "outputSchema": { "additionalProperties": true, "properties": { "action_required": { "description": "Null or an object with reason, message and optional action URL." }, "approval_id": { "description": "The purchase approval this call is about.", "type": "string" }, "approval_status": { "description": "Stored approval state; needs_login is the legacy name for any pause.", "type": "string" }, "approval_url": { "description": "Where the user approves — relay it.", "type": "string" }, "billing_note": { "description": "Explains the separation of tool fees and merchant payments.", "type": "string" }, "card_required": { "description": "True when a card must be added before this purchase.", "type": "boolean" }, "card_url": { "description": "Where the user adds a card, when they have none yet.", "type": "string" }, "charged_cents": { "description": "Amount billed for this call, in cents.", "type": "number" }, "command": { "description": "Which sub-command ran: setup | search | purchase | propose | status | checkout | reconcile | address | credentials.", "type": "string" }, "currency": { "description": "ISO currency of total_cents.", "type": "string" }, "error": { "description": "Error code/message when ok=false.", "type": "string" }, "expires_at": { "description": "When the approval stops being valid (24h from proposal).", "type": "string" }, "item": { "description": "What is being bought.", "type": "string" }, "live_view_url": { "description": "Live View link to the browser doing the checkout.", "type": "string" }, "login_url": { "description": "Live View link for the user to sign into their own merchant account.", "type": "string" }, "merchant": { "description": "Who it is being bought from.", "type": "string" }, "merchant_payment": { "description": "Merchant payment status and charged_cents, null when unverified. Separate from the tool fee.", "type": "object" }, "merchants": { "description": "Protocol merchants that sell this kind of thing.", "type": "array" }, "message": { "description": "What to show the user — relay it VERBATIM.", "type": "string" }, "next": { "description": "The next call to make.", "type": "string" }, "ok": { "description": "True when the call succeeded.", "type": "boolean" }, "order_status": { "description": "confirmed | not_confirmed | unknown | absent_user_reported.", "type": "string" }, "payment_source": { "description": "merchant_saved_card | link_card, once checkout picks one.", "type": "string" }, "receipt": { "description": "What was bought, once it completes.", "type": "object" }, "relay_verbatim": { "description": "True when `message` must be shown to the user as written.", "type": "boolean" }, "status": { "description": "proposed | approved | declined | checking_out | requires_action | completed | failed | expired.", "type": "string" }, "tool_fee_cents": { "description": "Vaaya buy tool-call fee. Not a merchant charge.", "type": "number" }, "total_cents": { "description": "The user's total, in cents — paid by their own card, not the balance.", "type": "number" }, "web": { "description": "Web search evidence, when `search` ran one." } }, "type": "object" }, "annotations": { "destructiveHint": false, "idempotentHint": false, "openWorldHint": true, "readOnlyHint": false, "title": "Buy Something for the User" } }, { "name": "session", "title": "Run Code in a Sandbox Session", "description": "Run a command or code in an open E2B sandbox session (started by `use` with action `create_session`, which returns a `session_id`). Pass `session_id` plus either `command` (a shell command) or `code` (+ optional `language`: python/javascript/bash). Returns stdout/stderr/exit_code (or the code result). The sandbox stays alive — and billed per second of uptime — until you `close` it; re-running reuses the SAME box, so filesystem + process state persist between calls. ALWAYS `close` when done.", "inputSchema": { "properties": { "code": { "description": "Code to execute (alternative to `command`).", "type": "string" }, "command": { "description": "Shell command to run in the sandbox.", "type": "string" }, "language": { "description": "Language for `code`: python (default), javascript, or bash.", "type": "string" }, "session_id": { "description": "The session_id returned by create_session.", "type": "string" } }, "required": [ "session_id" ], "type": "object" }, "outputSchema": { "additionalProperties": true, "properties": { "error": { "description": "Error code/message when ok=false.", "type": "string" }, "exit_code": { "description": "Process exit code.", "type": "number" }, "ok": { "description": "True when the call succeeded.", "type": "boolean" }, "result": { "description": "Structured result, when the runtime returns one." }, "stderr": { "description": "Captured standard error.", "type": "string" }, "stdout": { "description": "Captured standard output.", "type": "string" } }, "type": "object" }, "annotations": { "destructiveHint": false, "idempotentHint": false, "openWorldHint": true, "readOnlyHint": false, "title": "Run Code in a Sandbox Session" } }, { "name": "close", "title": "Close a Sandbox Session", "description": "Close an E2B sandbox session and stop its billing. Pass the `session_id`. Captures the final metered uptime cost and releases the hold. ALWAYS call this when finished with a session — an open session keeps billing per second of uptime. Safe to call repeatedly (idempotent).", "inputSchema": { "properties": { "session_id": { "description": "The session_id to close.", "type": "string" } }, "required": [ "session_id" ], "type": "object" }, "outputSchema": { "additionalProperties": true, "properties": { "balance_remaining_cents": { "description": "Wallet balance remaining, in cents.", "type": "number" }, "charged_cents": { "description": "Total metered uptime cost, in cents.", "type": "number" }, "error": { "description": "Error code/message when ok=false.", "type": "string" }, "ok": { "description": "True when the call succeeded.", "type": "boolean" }, "session_id": { "description": "The closed session id.", "type": "string" }, "status": { "description": "Final session state.", "type": "string" } }, "type": "object" }, "annotations": { "destructiveHint": false, "idempotentHint": true, "openWorldHint": false, "readOnlyHint": false, "title": "Close a Sandbox Session" } }, { "name": "llm", "title": "Ask Another LLM", "description": "Ask a DIFFERENT LLM a question and get its answer, billed per token from the Vaaya wallet (model cost + 3%, usually a fraction of a cent). Use it to get a second opinion from a rival model, cross-check an answer, summarize a huge blob cheaply, or query a specific model the user names (Kimi, GPT, Gemini, Claude, DeepSeek, and 300+ more). `model` accepts 'auto' (default: short prompts go cheap, long go mid), 'cheap' | 'mid' | 'best' tiers, or any exact OpenRouter slug like 'moonshotai/kimi-k3'. Typical costs: cheap tier well under 0.1 cents, best tier 1-3 cents per call. Not for the conversation you are already having — it is a one-shot ask to another model.", "inputSchema": { "properties": { "max_tokens": { "description": "Optional cap on the response length in tokens (default 4096, max 16384).", "type": "number" }, "model": { "description": "'auto' (default), 'cheap', 'mid', 'best', or an exact OpenRouter model slug (e.g. 'moonshotai/kimi-k3', 'anthropic/claude-opus-5').", "type": "string" }, "prompt": { "description": "The question or task for the other model.", "type": "string" }, "system": { "description": "Optional system prompt for the other model.", "type": "string" } }, "required": [ "prompt" ], "type": "object" }, "outputSchema": { "additionalProperties": true, "properties": { "charged_usd": { "description": "What the user pays for this call, in USD (model cost plus 3 percent).", "type": "number" }, "completion_tokens": { "description": "Completion tokens billed.", "type": "number" }, "error": { "description": "Error code/message when ok=false.", "type": "string" }, "model_used": { "description": "The concrete model that served the request.", "type": "string" }, "ok": { "description": "True when the call succeeded.", "type": "boolean" }, "prompt_tokens": { "description": "Prompt tokens billed.", "type": "number" }, "requested_model": { "description": "What the caller asked for ('auto', a tier, or a slug).", "type": "string" }, "text": { "description": "The other model's answer.", "type": "string" } }, "type": "object" }, "annotations": { "destructiveHint": false, "idempotentHint": false, "openWorldHint": true, "readOnlyHint": false, "title": "Ask Another LLM" } } ] }, "name": "Vaaya", "note": "Indexed from the official MCP registry: facts and our own checks, not reviewed, so no score, grade or rank.", "packages": [ { "registryType": "npm", "identifier": "@vaaya/mcp", "version": "0.6.8", "transport": "stdio" } ], "pageJsonUrl": "https://www.anchorterminal.com/tools/vaaya-mcp.json", "popularity": { "githubStars": 44, "npmWeekly": 118 }, "registryName": "ai.vaaya/mcp", "remotes": [ { "type": "streamable-http", "url": "https://vaaya.ai/mcp" } ], "repository": "https://github.com/vaaya-ai/vaaya-mcp", "reviewed": false, "slug": "vaaya-mcp", "source": "the official MCP registry", "sourceUrl": "https://registry.modelcontextprotocol.io/v0.1/servers?search=ai.vaaya/mcp", "summary": "Paid APIs and tokenized shares for agents. Prepaid funding, including authorized Instinct checkout.", "updatedAt": "2026-09-13T17:44:08Z", "url": "https://www.anchorterminal.com/tools/vaaya-mcp", "vendor": "vaaya.ai", "vendorUrl": "https://vaaya.ai", "version": "0.6.8", "websiteUrl": "https://vaaya.ai", "where": "both", "why": [ "vendor" ] } }