Skip to main content
Glama

Routavo

by com.routavo
OverviewDiscussionsAdmin

Call an API

call

Route a call to the Routavo network, meter it, and return the result. Give either a provider id from discover(), or a capability and let Routavo pick using its published routing rule. Optional max_price and max_latency_ms constrain the choice. Failed calls are recorded but cost nothing.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
planNoInstead of one call, a sequence of up to 8 steps: [{ id, capability | provider, arguments, max_price?, max_latency_ms? }]. A later step may take a value from an earlier one with { "$ref": "<step id>.output.<path>" }, e.g. { "$ref": "geo.output.results[0].lat" }. The whole plan is quoted before anything runs; with dry_run it is only quoted. Steps run in order and stop at the first failure. Each step returns its own receipt and the response carries one total.
batchNoInstead of one arguments object, up to 50 of them for the same capability or provider. Run in parallel, each with its own receipt, one total. Failed items cost nothing and do not stop the others.
budgetNoA task budget: { id, max }. Spend under this id is tracked across any number of calls, plans and batches, and a call that would take it past max is refused with code "budget". { id, statement: true } returns what the budget has spent and the receipts behind it.
fieldsNoReturn only these output paths, e.g. ["results.name", "results.lat", "results.lng"]. Saves tokens; the receipt still hashes the full answer.
quorumNoAsk 2 or 3 providers the same question and get an agreement score with every answer. Each provider is charged. Refused if fewer providers clear your constraints, so quote it first with dry_run.
recipeNoA named, published plan, e.g. "weather_for_place". Give its arguments and it runs the steps for you, quoted first, with the last step's output on top. discover() lists recipes with their inputs and estimated price.
walletNoYour wallet address, asserted. Attributes metering and a daily cap on the free tier; it proves nothing. To pay from a balance, prove the wallet once at /api/wallet and send the key it returns as wallet_key or as Authorization: Bearer rw_...
countryNoTwo letter code for where this request is, e.g. "FR". A routing hint, not an argument to the API: it lets a provider that covers only that country be chosen, and keeps one that does not out of the running. Unnecessary when the arguments already carry coordinates.
dry_runNoQuote only: which provider would be chosen, at what price, with what latency, and why. Nothing is called, charged or counted.
paymentNoPay this one call with x402: { rail: "x402", payload: <PaymentPayload> }, an EIP-3009 authorization to the pay-to address for at least the price, signed by your wallet. The requirements to sign are in discover() and in any payment_required error. A facilitator verifies and settles it; the receipt carries the transaction.
failoverNoDefault true when routing by capability: if the chosen provider fails, the next eligible one is tried and only the one that answered is charged. Set false to fail fast.
providerNoProvider id, e.g. "open-meteo.geocode". Omit to route by capability.
argumentsNoArguments in the capability contract shape from discover(). Learn geocode once; every provider behind it takes the same input and returns the same output.
max_priceNoDo not route above this price per call, e.g. "0.0030"
max_totalNoFor a plan: do not run if the quoted total exceeds this, e.g. "0.0100".
capabilityNoCapability to route on, e.g. "geocode". Ignored when provider is given.
wallet_keyNoA wallet key (rw_...) from /api/wallet. Proves the wallet, and calls are paid from its deposited USDC balance. Prefer sending it as the Authorization: Bearer header.
max_latency_msNoDo not route to a provider slower than this p50
idempotency_keyNoYour own id for this call, up to 64 characters. A retry with the same key within 24 hours returns the same result and receipt and is never charged again. The output is kept for those 24 hours only because you asked for replay.

Schema Changelog

Changes observed during successful MCP inspections.

  1. Changed1 schema field changed
    • addedInput schema / properties / country
      Added value: +{
+  "description": "Two letter code for where this request is, e.g. \"FR\". A routing hint, not an argument to the API: it lets a provider that covers only that country be chosen, and keeps one that does not out of the running. Unnecessary when the arguments already carry coordinates.",
+  "type": "string"
+}
  2. First observed

TDQS

A4.2/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the behavioral disclosure burden. It adds important facts: calls are metered, failed calls are recorded but cost nothing, and routing can be constrained by price and latency. It does not cover advanced behaviors like dry-run quoting, budgets, or payment, but the schema documents those separately.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three sentences with no filler. The core function is front-loaded, the provider/capability decision follows immediately, and the cost/failure semantics close it out. Every sentence earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is complex with 19 parameters and no output schema, but the schema descriptions are exhaustive. Given that richness, the description covers the essential selection-level information: what the tool does, how routing works, and cost/failure behavior. It does not need to restate every parameter, though a brief mention of dry_run or plan/batch modes would be a small improvement.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the baseline is 3. The description does add a useful routing rule ('provider id from discover()' vs 'capability'), but this largely restates what the individual param descriptions already say for provider, capability, max_price, and max_latency_ms. It adds little meaning beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb and resource: 'Route a call to the Routavo network, meter it, and return the result.' It clearly names the tool's operation and even points to the sibling discover() as the source of provider ids, which separates call from discovery. This is a strong, non-tautological definition.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives concrete guidance on how to select routing: provide a provider id from discover(), or provide a capability and let Routavo route. It also mentions optional constraints (max_price, max_latency_ms). It does not explicitly state when not to use this tool versus dispute or verify, but the core invocation guidance is clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

All Routavo toolsInspect
Try in Browser
One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

Glama MCP Gateway

Add one secure layer between your agents and this server.

Resources